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


#define SWIG_VERSION 0x040100
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
#define SWIGPYTHON_FASTPROXY

/* -----------------------------------------------------------------------------
 *  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(__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

/* -----------------------------------------------------------------------------
 * 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 "4"

/* 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 temporal 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 cast in linked list */
  struct swig_cast_info  *prev;			/* pointer to the previous cast */
} 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;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  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 *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  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


/* 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

#ifndef Py_TYPE
#  define Py_TYPE(op) ((op)->ob_type)
#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


SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03030000
  return (char *)PyUnicode_AsUTF8(str);
#else
  return PyString_AsString(str);
#endif
}

/* Was useful for Python 3.0.x-3.2.x - now provided only for compatibility
 * with any uses in user interface files. */
#define SWIG_Python_str_DelForPy3(x)


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

#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

/* 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_data" SWIG_RUNTIME_VERSION "." 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

/* -----------------------------------------------------------------------------
 * 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;
  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);
    const char *tmp = SWIG_Python_str_AsChar(old_str);
    PyErr_Clear();
    Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    Py_DECREF(old_str);
    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) {
      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) { PyEval_RestoreThread(save); status = false; }}
         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 < 0x03030000
# error "This version of SWIG only supports Python 3 >= 3.3"
#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);
  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);
  Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  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);
  Py_DECREF(obj);                            
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    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 {
        Py_DECREF(obj);
        return o2;
      }
    }
    PyList_Append(result,obj);
    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 *
swig_varlink_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 *
swig_varlink_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);
    Py_DecRef(str);
    Py_DecRef(tail);
    str = joined;
    if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
    }
  }
  tail = PyUnicode_InternFromString(")");
  joined = PyUnicode_Concat(str, tail);
  Py_DecRef(str);
  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
swig_varlink_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 *
swig_varlink_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
swig_varlink_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*
swig_varlink_type(void) {
  static char varlink__doc__[] = "Swig var link object";
  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
      "swigvarlink",                      /* tp_name */
      sizeof(swig_varlinkobject),         /* tp_basicsize */
      0,                                  /* tp_itemsize */
      (destructor) swig_varlink_dealloc,  /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /*tp_print*/
#else
      (Py_ssize_t)0,                      /*tp_vectorcall_offset*/
#endif
      (getattrfunc) swig_varlink_getattr, /* tp_getattr */
      (setattrfunc) swig_varlink_setattr, /* tp_setattr */
      0,                                  /* tp_compare */
      (reprfunc) swig_varlink_repr,       /* tp_repr */
      0,                                  /* tp_as_number */
      0,                                  /* tp_as_sequence */
      0,                                  /* tp_as_mapping */
      0,                                  /* tp_hash */
      0,                                  /* tp_call */
      (reprfunc) swig_varlink_str,        /* tp_str */
      0,                                  /* tp_getattro */
      0,                                  /* tp_setattro */
      0,                                  /* tp_as_buffer */
      0,                                  /* tp_flags */
      varlink__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
#ifdef COUNT_ALLOCS
      0,                                  /* tp_allocs */
      0,                                  /* tp_frees */
      0,                                  /* tp_maxalloc */
      0,                                  /* tp_prev */
      0                                   /* tp_next */
#endif
    };
    varlink_type = tmp;
    type_init = 1;
    if (PyType_Ready(&varlink_type) < 0)
      return NULL;
  }
  return &varlink_type;
}

/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_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;
  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;
    Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      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) {
          Py_INCREF(obj);
          PyTuple_SET_ITEM(data->newargs, 0, obj);
        } else {
          Py_DECREF(data->newraw);
          Py_DECREF(data->klass);
          free(data);
          return 0;
        }
      } else {
        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)
{
  Py_XDECREF(data->klass);
  Py_XDECREF(data->newraw);
  Py_XDECREF(data->newargs);
  Py_XDECREF(data->destroy);
  free(data);
}

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

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
  PyObject *dict;
#endif
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

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

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

  Py_XINCREF(sobj->dict);
  return sobj->dict;
}

#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
        Py_DECREF(ofmt);
      }
    }
    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);
      Py_DecRef(repr);
      Py_DecRef(nrep);
      repr = joined;
# else
      PyString_ConcatAndDel(&repr,nrep);
# endif
    } else {
      Py_DecRef(repr);
      repr = NULL;
    }
  }
  return repr;
}

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

SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
  void *i = v->ptr;
  void *j = w->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
  PyObject* res;
  if( op != Py_EQ && op != Py_NE ) {
    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) {
#ifdef SWIGPYTHON_BUILTIN
  PyTypeObject *target_tp = SwigPyObject_type();
  if (PyType_IsSubtype(op->ob_type, target_tp))
    return 1;
  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
  return (Py_TYPE(op) == SwigPyObject_type())
    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#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;
        }
        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);

      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
    Py_XDECREF(Swig_Capsule_global);
  }
  Py_XDECREF(next);
#ifdef SWIGPYTHON_BUILTIN
  Py_XDECREF(sobj->dict);
#endif
  PyObject_DEL(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;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    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)) {
        Py_DECREF(SwigPyObject_acquire(v,args));
      } else {
        Py_DECREF(SwigPyObject_disown(v,args));
      }
    } 
    return obj;
  }
}

static PyMethodDef
swigobject_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 swigobject_doc[] = "Swig object carries a C/C++ instance pointer";

  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
      "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 */
      swigobject_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      swigobject_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
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) != 0)
      return NULL;
  }
  return &swigpyobject_type;
}

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;
#ifdef SWIGPYTHON_BUILTIN
    sobj->dict = 0;
#endif
    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) */
      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) {
  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}

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

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
  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
      "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 */
      swigpacked_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
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) != 0)
      return NULL;
  }
  return &swigpypacked_type;
}

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_DEL((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

SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

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

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
# ifdef PyWeakref_CheckProxy
  if (PyWeakref_CheckProxy(pyobj)) {
    pyobj = PyWeakref_GET_OBJECT(pyobj);
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
# endif
  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 {
#ifdef PyWeakref_CheckProxy
      if (PyWeakref_CheckProxy(pyobj)) {
	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
#endif
      obj = PyObject_GetAttr(pyobj,SWIG_This());
      if (obj) {
	Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj,SWIG_This());
  if (obj) {
    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);		    
                }
              }
            }
            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 */
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    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{
          Py_DECREF(inst);
          inst = 0;
        }
      }
#else
      if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        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) {
        inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        Py_DECREF(empty_kwargs);
        if (inst) {
          if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
            Py_DECREF(inst);
            inst = 0;
          } else {
            PyType_Modified(Py_TYPE(inst));
          }
        }
      }
      Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      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) {
      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) {
        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
        newobj->dict = 0;
#endif
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
      if (newobj) {
        newobj->dict = 0;
      }
#endif
    }
    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);
    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;
}


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);
    }
  }
  Py_DECREF(SWIG_This());
  Swig_This_global = NULL;
  Py_DECREF(SWIG_globals());
  Swig_Globals_global = NULL;
  Py_DECREF(SWIG_Python_TypeCache());
  Swig_TypeCache_global = NULL;
  Swig_Capsule_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
 /* Add a dummy module object into sys.modules */
  PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    if (PyModule_AddObject(module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
      ++interpreter_counter;
      Swig_Capsule_global = pointer;
    } else {
      Py_DECREF(pointer);
    }
  } else {
    Py_XDECREF(pointer);
  }
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *key = SWIG_Python_str_FromChar(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  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_SetItem(cache, key, obj);
        Py_DECREF(obj);
      }
    }
  }
  Py_DECREF(key);
  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);
      const char *tmp = SWIG_Python_str_AsChar(old_str);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      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 : "";
}

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (obj && SwigPyObject_Check(obj)) {
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	Py_XDECREF(str);
	return;
      }
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}


/* 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 = obj->ob_type;
  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
  {
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    return -1;
  } else {
    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 = descr->ob_type->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        goto done;
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  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) 



#ifdef __cplusplus
extern "C" {
#endif

/* Method creation and docstring support functions */

SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);

#ifdef __cplusplus
}
#endif


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


#include <memory>

// The bdd_dict object stores pointers to keep track of who
// uses which BDD variables.  If this is a C++ object, we
// would like to use its this pointer (not the Python pointer).
// If this is a shared_ptr, we would like to use the address of
// of the pointed object, not that of the shared ptr.  Finally,
// we also want to allow Python objects in there,

static void* ptr_for_bdddict(PyObject* obj)
{
  void* ptr = obj;
  if (SwigPyObject* swig_obj = SWIG_Python_GetSwigThis(obj))
    {
      ptr = swig_obj->ptr;
      const char *type = SWIG_TypePrettyName(swig_obj->ty);
      if (strncmp(type, "std::shared_ptr<", 16) == 0)
        ptr = reinterpret_cast<std::shared_ptr<void>*>(ptr)->get();
    }
  return ptr;
}


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

#define SWIGTYPE_p_aliases_t swig_types[0]
#define SWIGTYPE_p_allocator_type swig_types[1]
#define SWIGTYPE_p_bdd swig_types[2]
#define SWIGTYPE_p_bdd_info_map swig_types[3]
#define SWIGTYPE_p_bitvect swig_types[4]
#define SWIGTYPE_p_bool swig_types[5]
#define SWIGTYPE_p_char swig_types[6]
#define SWIGTYPE_p_const_reference swig_types[7]
#define SWIGTYPE_p_const_states_set_t swig_types[8]
#define SWIGTYPE_p_data_t swig_types[9]
#define SWIGTYPE_p_difference_type swig_types[10]
#define SWIGTYPE_p_dv_t swig_types[11]
#define SWIGTYPE_p_ec_statistics swig_types[12]
#define SWIGTYPE_p_edge swig_types[13]
#define SWIGTYPE_p_edge_filter swig_types[14]
#define SWIGTYPE_p_edge_filter_choice swig_types[15]
#define SWIGTYPE_p_edge_storage_t swig_types[16]
#define SWIGTYPE_p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice swig_types[17]
#define SWIGTYPE_p_first_type swig_types[18]
#define SWIGTYPE_p_fixed_size_poolT_pool_type__Safe_t swig_types[19]
#define SWIGTYPE_p_fnode swig_types[20]
#define SWIGTYPE_p_fv_map swig_types[21]
#define SWIGTYPE_p_graph_t swig_types[22]
#define SWIGTYPE_p_int swig_types[23]
#define SWIGTYPE_p_iter_t swig_types[24]
#define SWIGTYPE_p_iterator_category swig_types[25]
#define SWIGTYPE_p_key_type swig_types[26]
#define SWIGTYPE_p_long_long swig_types[27]
#define SWIGTYPE_p_mapped_type swig_types[28]
#define SWIGTYPE_p_output_aborter swig_types[29]
#define SWIGTYPE_p_output_pref swig_types[30]
#define SWIGTYPE_p_p_PyObject swig_types[31]
#define SWIGTYPE_p_p_char swig_types[32]
#define SWIGTYPE_p_p_f_r_q_const__std__vector__unsigned_int_std__allocator__unsigned_int_____p_void__void swig_types[33]
#define SWIGTYPE_p_power_state swig_types[34]
#define SWIGTYPE_p_prop_map swig_types[35]
#define SWIGTYPE_p_ref_set swig_types[36]
#define SWIGTYPE_p_repr_t swig_types[37]
#define SWIGTYPE_p_rs_pairs swig_types[38]
#define SWIGTYPE_p_safe_point swig_types[39]
#define SWIGTYPE_p_safe_stash swig_types[40]
#define SWIGTYPE_p_scc_node swig_types[41]
#define SWIGTYPE_p_scc_succs swig_types[42]
#define SWIGTYPE_p_second_type swig_types[43]
#define SWIGTYPE_p_seq_t swig_types[44]
#define SWIGTYPE_p_short swig_types[45]
#define SWIGTYPE_p_signed_char swig_types[46]
#define SWIGTYPE_p_size_type swig_types[47]
#define SWIGTYPE_p_spot__acc_cond swig_types[48]
#define SWIGTYPE_p_spot__acc_cond__acc_code swig_types[49]
#define SWIGTYPE_p_spot__acc_cond__acc_word swig_types[50]
#define SWIGTYPE_p_spot__acc_cond__mark_t swig_types[51]
#define SWIGTYPE_p_spot__acc_cond__rs_pair swig_types[52]
#define SWIGTYPE_p_spot__acd swig_types[53]
#define SWIGTYPE_p_spot__aig swig_types[54]
#define SWIGTYPE_p_spot__automaton_parser_options swig_types[55]
#define SWIGTYPE_p_spot__automaton_stream_parser swig_types[56]
#define SWIGTYPE_p_spot__bdd_dict swig_types[57]
#define SWIGTYPE_p_spot__declarative_environment swig_types[58]
#define SWIGTYPE_p_spot__default_environment swig_types[59]
#define SWIGTYPE_p_spot__digraphT_spot__kripke_graph_state_void_t swig_types[60]
#define SWIGTYPE_p_spot__digraphT_spot__kripke_graph_state_void_t__edge swig_types[61]
#define SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t swig_types[62]
#define SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge swig_types[63]
#define SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_storage_t swig_types[64]
#define SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__state_storage_t swig_types[65]
#define SWIGTYPE_p_spot__emptiness_check swig_types[66]
#define SWIGTYPE_p_spot__emptiness_check_instantiator swig_types[67]
#define SWIGTYPE_p_spot__emptiness_check_result swig_types[68]
#define SWIGTYPE_p_spot__environment swig_types[69]
#define SWIGTYPE_p_spot__fair_kripke swig_types[70]
#define SWIGTYPE_p_spot__fair_kripke_succ_iterator swig_types[71]
#define SWIGTYPE_p_spot__formula swig_types[72]
#define SWIGTYPE_p_spot__game_relabeling_map swig_types[73]
#define SWIGTYPE_p_spot__hoa_alias_formater swig_types[74]
#define SWIGTYPE_p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t swig_types[75]
#define SWIGTYPE_p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t swig_types[76]
#define SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t swig_types[77]
#define SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t swig_types[78]
#define SWIGTYPE_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t swig_types[79]
#define SWIGTYPE_p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t swig_types[80]
#define SWIGTYPE_p_spot__internal__boxed_labelT_void_true_t swig_types[81]
#define SWIGTYPE_p_spot__internal__const_universal_dests swig_types[82]
#define SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t swig_types[83]
#define SWIGTYPE_p_spot__internal__edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t swig_types[84]
#define SWIGTYPE_p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t swig_types[85]
#define SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t swig_types[86]
#define SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t swig_types[87]
#define SWIGTYPE_p_spot__internal__keep_all swig_types[88]
#define SWIGTYPE_p_spot__internal__keep_inner_scc swig_types[89]
#define SWIGTYPE_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t swig_types[90]
#define SWIGTYPE_p_spot__internal__mark_container swig_types[91]
#define SWIGTYPE_p_spot__internal__mark_iterator swig_types[92]
#define SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t swig_types[93]
#define SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__dv_t swig_types[94]
#define SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__state_iterator swig_types[95]
#define SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__sv_t swig_types[96]
#define SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__tv_t swig_types[97]
#define SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t swig_types[98]
#define SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__dv_t swig_types[99]
#define SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__state_iterator swig_types[100]
#define SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__sv_t swig_types[101]
#define SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__tv_t swig_types[102]
#define SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t swig_types[103]
#define SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t swig_types[104]
#define SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t swig_types[105]
#define SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t swig_types[106]
#define SWIGTYPE_p_spot__internal__succ_iterator swig_types[107]
#define SWIGTYPE_p_spot__isomorphism_checker swig_types[108]
#define SWIGTYPE_p_spot__kripke swig_types[109]
#define SWIGTYPE_p_spot__kripke_graph swig_types[110]
#define SWIGTYPE_p_spot__kripke_graph_state swig_types[111]
#define SWIGTYPE_p_spot__kripke_graph_succ_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t swig_types[112]
#define SWIGTYPE_p_spot__kripke_succ_iterator swig_types[113]
#define SWIGTYPE_p_spot__language_containment_checker swig_types[114]
#define SWIGTYPE_p_spot__location swig_types[115]
#define SWIGTYPE_p_spot__mealy_like swig_types[116]
#define SWIGTYPE_p_spot__minato_isop swig_types[117]
#define SWIGTYPE_p_spot__nca_st_info swig_types[118]
#define SWIGTYPE_p_spot__option_map swig_types[119]
#define SWIGTYPE_p_spot__outedge_combiner swig_types[120]
#define SWIGTYPE_p_spot__output_aborter swig_types[121]
#define SWIGTYPE_p_spot__parallel_policy swig_types[122]
#define SWIGTYPE_p_spot__parse_aut_error_list swig_types[123]
#define SWIGTYPE_p_spot__parse_error swig_types[124]
#define SWIGTYPE_p_spot__parse_error_list swig_types[125]
#define SWIGTYPE_p_spot__parsed_aut swig_types[126]
#define SWIGTYPE_p_spot__parsed_formula swig_types[127]
#define SWIGTYPE_p_spot__postprocessor swig_types[128]
#define SWIGTYPE_p_spot__power_map swig_types[129]
#define SWIGTYPE_p_spot__printable_acc_cond swig_types[130]
#define SWIGTYPE_p_spot__printable_formula swig_types[131]
#define SWIGTYPE_p_spot__printable_long_size swig_types[132]
#define SWIGTYPE_p_spot__printable_scc_info swig_types[133]
#define SWIGTYPE_p_spot__printable_size swig_types[134]
#define SWIGTYPE_p_spot__randltlgenerator swig_types[135]
#define SWIGTYPE_p_spot__random_boolean swig_types[136]
#define SWIGTYPE_p_spot__random_formula swig_types[137]
#define SWIGTYPE_p_spot__random_ltl swig_types[138]
#define SWIGTYPE_p_spot__random_psl swig_types[139]
#define SWIGTYPE_p_spot__random_sere swig_types[140]
#define SWIGTYPE_p_spot__reduce_parity_data swig_types[141]
#define SWIGTYPE_p_spot__remove_ap swig_types[142]
#define SWIGTYPE_p_spot__rs_pairs_view swig_types[143]
#define SWIGTYPE_p_spot__scc_and_mark_filter swig_types[144]
#define SWIGTYPE_p_spot__scc_info swig_types[145]
#define SWIGTYPE_p_spot__scc_info_node swig_types[146]
#define SWIGTYPE_p_spot__set_state swig_types[147]
#define SWIGTYPE_p_spot__stat_printer swig_types[148]
#define SWIGTYPE_p_spot__state swig_types[149]
#define SWIGTYPE_p_spot__state_product swig_types[150]
#define SWIGTYPE_p_spot__state_ptr_equal swig_types[151]
#define SWIGTYPE_p_spot__state_ptr_hash swig_types[152]
#define SWIGTYPE_p_spot__state_ptr_less_than swig_types[153]
#define SWIGTYPE_p_spot__state_shared_ptr_equal swig_types[154]
#define SWIGTYPE_p_spot__state_shared_ptr_hash swig_types[155]
#define SWIGTYPE_p_spot__state_shared_ptr_less_than swig_types[156]
#define SWIGTYPE_p_spot__state_ta_explicit swig_types[157]
#define SWIGTYPE_p_spot__state_unicity_table swig_types[158]
#define SWIGTYPE_p_spot__synthesis_info swig_types[159]
#define SWIGTYPE_p_spot__ta swig_types[160]
#define SWIGTYPE_p_spot__ta_explicit swig_types[161]
#define SWIGTYPE_p_spot__ta_explicit_succ_iterator swig_types[162]
#define SWIGTYPE_p_spot__ta_statistics swig_types[163]
#define SWIGTYPE_p_spot__ta_succ_iterator swig_types[164]
#define SWIGTYPE_p_spot__taa_succ_iterator swig_types[165]
#define SWIGTYPE_p_spot__taa_tgba swig_types[166]
#define SWIGTYPE_p_spot__taa_tgba__transition swig_types[167]
#define SWIGTYPE_p_spot__taa_tgba_formula swig_types[168]
#define SWIGTYPE_p_spot__taa_tgba_string swig_types[169]
#define SWIGTYPE_p_spot__tgta swig_types[170]
#define SWIGTYPE_p_spot__tgta_explicit swig_types[171]
#define SWIGTYPE_p_spot__tl_simplifier swig_types[172]
#define SWIGTYPE_p_spot__tl_simplifier_options swig_types[173]
#define SWIGTYPE_p_spot__to_parity_data swig_types[174]
#define SWIGTYPE_p_spot__to_parity_options swig_types[175]
#define SWIGTYPE_p_spot__translator swig_types[176]
#define SWIGTYPE_p_spot__trival swig_types[177]
#define SWIGTYPE_p_spot__twa swig_types[178]
#define SWIGTYPE_p_spot__twa__prop_set swig_types[179]
#define SWIGTYPE_p_spot__twa_graph swig_types[180]
#define SWIGTYPE_p_spot__twa_graph_edge_data swig_types[181]
#define SWIGTYPE_p_spot__twa_graph_state swig_types[182]
#define SWIGTYPE_p_spot__twa_product swig_types[183]
#define SWIGTYPE_p_spot__twa_product_init swig_types[184]
#define SWIGTYPE_p_spot__twa_run swig_types[185]
#define SWIGTYPE_p_spot__twa_run__step swig_types[186]
#define SWIGTYPE_p_spot__twa_statistics swig_types[187]
#define SWIGTYPE_p_spot__twa_sub_statistics swig_types[188]
#define SWIGTYPE_p_spot__twa_succ_iterator swig_types[189]
#define SWIGTYPE_p_spot__twa_univ_remover swig_types[190]
#define SWIGTYPE_p_spot__twa_word swig_types[191]
#define SWIGTYPE_p_spot__unabbreviator swig_types[192]
#define SWIGTYPE_p_spot__univ_remover_state swig_types[193]
#define SWIGTYPE_p_spot__zielonka_tree swig_types[194]
#define SWIGTYPE_p_state swig_types[195]
#define SWIGTYPE_p_state_iterator swig_types[196]
#define SWIGTYPE_p_state_num swig_types[197]
#define SWIGTYPE_p_state_set swig_types[198]
#define SWIGTYPE_p_state_storage_t swig_types[199]
#define SWIGTYPE_p_state_vector swig_types[200]
#define SWIGTYPE_p_states_set_t swig_types[201]
#define SWIGTYPE_p_std__allocatorT_bdd_t swig_types[202]
#define SWIGTYPE_p_std__allocatorT_bool_t swig_types[203]
#define SWIGTYPE_p_std__allocatorT_int_t swig_types[204]
#define SWIGTYPE_p_std__allocatorT_spot__acc_cond__acc_code_t swig_types[205]
#define SWIGTYPE_p_std__allocatorT_spot__acc_cond__rs_pair_t swig_types[206]
#define SWIGTYPE_p_std__allocatorT_spot__acc_cond_t swig_types[207]
#define SWIGTYPE_p_std__allocatorT_spot__formula_t swig_types[208]
#define SWIGTYPE_p_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t swig_types[209]
#define SWIGTYPE_p_std__allocatorT_spot__twa_run__step_t swig_types[210]
#define SWIGTYPE_p_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t swig_types[211]
#define SWIGTYPE_p_std__allocatorT_std__pairT_std__string_bdd_t_t swig_types[212]
#define SWIGTYPE_p_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t swig_types[213]
#define SWIGTYPE_p_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t swig_types[214]
#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[215]
#define SWIGTYPE_p_std__allocatorT_unsigned_int_t swig_types[216]
#define SWIGTYPE_p_std__conditionalT_std__is_constT_spot__digraphT_spot__kripke_graph_state_void_t_t__value_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_const_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_t__type swig_types[217]
#define SWIGTYPE_p_std__conditionalT_std__is_constT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t__value_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_const_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_t__type swig_types[218]
#define SWIGTYPE_p_std__functionT_std__string_fintF_t swig_types[219]
#define SWIGTYPE_p_std__functionT_void_fstd__ostream_R_intF_t swig_types[220]
#define SWIGTYPE_p_std__initializer_listT_unsigned_int_t swig_types[221]
#define SWIGTYPE_p_std__invalid_argument swig_types[222]
#define SWIGTYPE_p_std__istream swig_types[223]
#define SWIGTYPE_p_std__lessT_spot__formula_t swig_types[224]
#define SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t swig_types[225]
#define SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t swig_types[226]
#define SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t swig_types[227]
#define SWIGTYPE_p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t swig_types[228]
#define SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t swig_types[229]
#define SWIGTYPE_p_std__mapT_std__string_const_spot__formula_std__lessT_std__string_const_t_std__allocatorT_std__pairT_std__string_const_const_spot__formula_t_t_t swig_types[230]
#define SWIGTYPE_p_std__nullptr_t swig_types[231]
#define SWIGTYPE_p_std__ofstream swig_types[232]
#define SWIGTYPE_p_std__optionalT_spot__synthesis_info__bench_var_t swig_types[233]
#define SWIGTYPE_p_std__ostream swig_types[234]
#define SWIGTYPE_p_std__ostringstream swig_types[235]
#define SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t swig_types[236]
#define SWIGTYPE_p_std__pairT_int_spot__acc_cond__acc_code_t swig_types[237]
#define SWIGTYPE_p_std__pairT_int_spot__acc_cond_t swig_types[238]
#define SWIGTYPE_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t swig_types[239]
#define SWIGTYPE_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t swig_types[240]
#define SWIGTYPE_p_std__pairT_std__string_bdd_t swig_types[241]
#define SWIGTYPE_p_std__pairT_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t_std__vectorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_std__allocatorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_t_t_t swig_types[242]
#define SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t swig_types[243]
#define SWIGTYPE_p_std__runtime_error swig_types[244]
#define SWIGTYPE_p_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t swig_types[245]
#define SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t swig_types[246]
#define SWIGTYPE_p_std__setT_spot__state_const_p_spot__state_ptr_less_than_std__allocatorT_spot__state_const_p_t_t swig_types[247]
#define SWIGTYPE_p_std__setT_spot__state_p_spot__state_ptr_less_than_std__allocatorT_spot__state_p_t_t swig_types[248]
#define SWIGTYPE_p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t swig_types[249]
#define SWIGTYPE_p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t swig_types[250]
#define SWIGTYPE_p_std__shared_ptrT_spot__aig_const_t swig_types[251]
#define SWIGTYPE_p_std__shared_ptrT_spot__aig_t swig_types[252]
#define SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t swig_types[253]
#define SWIGTYPE_p_std__shared_ptrT_spot__dstar_aut_t swig_types[254]
#define SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_instantiator_t swig_types[255]
#define SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t swig_types[256]
#define SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t swig_types[257]
#define SWIGTYPE_p_std__shared_ptrT_spot__fair_kripke_t swig_types[258]
#define SWIGTYPE_p_std__shared_ptrT_spot__kripke_const_t swig_types[259]
#define SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t swig_types[260]
#define SWIGTYPE_p_std__shared_ptrT_spot__kripke_t swig_types[261]
#define SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_const_t swig_types[262]
#define SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t swig_types[263]
#define SWIGTYPE_p_std__shared_ptrT_spot__state_const_t swig_types[264]
#define SWIGTYPE_p_std__shared_ptrT_spot__ta_const_t swig_types[265]
#define SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_const_t swig_types[266]
#define SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t swig_types[267]
#define SWIGTYPE_p_std__shared_ptrT_spot__ta_product_t swig_types[268]
#define SWIGTYPE_p_std__shared_ptrT_spot__ta_t swig_types[269]
#define SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_formula_const_t swig_types[270]
#define SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_formula_t swig_types[271]
#define SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_string_const_t swig_types[272]
#define SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_string_t swig_types[273]
#define SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_t swig_types[274]
#define SWIGTYPE_p_std__shared_ptrT_spot__tgbasl_t swig_types[275]
#define SWIGTYPE_p_std__shared_ptrT_spot__tgta_const_t swig_types[276]
#define SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_const_t swig_types[277]
#define SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t swig_types[278]
#define SWIGTYPE_p_std__shared_ptrT_spot__tgta_t swig_types[279]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_const_t swig_types[280]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_const_t swig_types[281]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t swig_types[282]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_product_const_t swig_types[283]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_product_init_t swig_types[284]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_product_t swig_types[285]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_run_const_t swig_types[286]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t swig_types[287]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_t swig_types[288]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_univ_remover_t swig_types[289]
#define SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t swig_types[290]
#define SWIGTYPE_p_std__tupleT_int_spot__acc_cond__acc_code_spot__acc_cond__acc_code_t swig_types[291]
#define SWIGTYPE_p_std__tupleT_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t_std__vectorT_std__pairT_unsigned_int_bdd_t_std__allocatorT_std__pairT_unsigned_int_bdd_t_t_t_std__vectorT_bdd_std__allocatorT_bdd_t_t_t swig_types[292]
#define SWIGTYPE_p_std__tupleT_t swig_types[293]
#define SWIGTYPE_p_std__unordered_setT_spot__state_const_p_spot__state_ptr_hash_spot__state_ptr_equal_t swig_types[294]
#define SWIGTYPE_p_std__unordered_setT_std__shared_ptrT_spot__state_const_t_spot__state_shared_ptr_hash_spot__state_shared_ptr_equal_t swig_types[295]
#define SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t swig_types[296]
#define SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t swig_types[297]
#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[298]
#define SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t swig_types[299]
#define SWIGTYPE_p_std__vectorT_spot__acc_cond__mark_t_std__allocatorT_spot__acc_cond__mark_t_t_t swig_types[300]
#define SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t swig_types[301]
#define SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t swig_types[302]
#define SWIGTYPE_p_std__vectorT_spot__bdd_dict__bdd_info_std__allocatorT_spot__bdd_dict__bdd_info_t_t swig_types[303]
#define SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t swig_types[304]
#define SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t swig_types[305]
#define SWIGTYPE_p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t swig_types[306]
#define SWIGTYPE_p_std__vectorT_spot__nca_st_info_p_std__allocatorT_spot__nca_st_info_p_t_t swig_types[307]
#define SWIGTYPE_p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator swig_types[308]
#define SWIGTYPE_p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_reverse_iterator swig_types[309]
#define SWIGTYPE_p_std__vectorT_spot__zielonka_tree__zielonka_node_std__allocatorT_spot__zielonka_tree__zielonka_node_t_t swig_types[310]
#define SWIGTYPE_p_std__vectorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_std__allocatorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_t_t swig_types[311]
#define SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t swig_types[312]
#define SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t swig_types[313]
#define SWIGTYPE_p_std__vectorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_std__allocatorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_t_t swig_types[314]
#define SWIGTYPE_p_std__vectorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_std__allocatorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_t_t swig_types[315]
#define SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t swig_types[316]
#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[317]
#define SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t swig_types[318]
#define SWIGTYPE_p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t swig_types[319]
#define SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t swig_types[320]
#define SWIGTYPE_p_steps swig_types[321]
#define SWIGTYPE_p_sv_t swig_types[322]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[323]
#define SWIGTYPE_p_tv_t swig_types[324]
#define SWIGTYPE_p_unsigned_char swig_types[325]
#define SWIGTYPE_p_unsigned_int swig_types[326]
#define SWIGTYPE_p_unsigned_long_long swig_types[327]
#define SWIGTYPE_p_unsigned_short swig_types[328]
#define SWIGTYPE_p_unsigned_statistics swig_types[329]
#define SWIGTYPE_p_value_type swig_types[330]
#define SWIGTYPE_p_vf_map swig_types[331]
#define SWIGTYPE_p_void swig_types[332]
static swig_type_info *swig_types[334];
static swig_module_info swig_module = {swig_types, 333, 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):= _impl.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__impl

#else
#  define SWIG_init    init_impl

#endif
#define SWIG_name    "_impl"

#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;
      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;
        Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      Py_XINCREF(item._obj);
      Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      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)
    {
      Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}


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


#include <iostream>

#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICE_ARG(obj) ((PyObject*) (obj))
#else
# define SWIGPY_SLICE_ARG(obj) ((PySliceObject*) (obj))
#endif


#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>


namespace swig {
  struct stop_iteration {
  };

  struct SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

  protected:
    SwigPyIterator(PyObject *seq) : _seq(seq)
    {
    }
      
  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
    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
    {
      throw stop_iteration();
    }

    // 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();
      incr();       
      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       
      decr();
      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)
    {
      return *advance(n);
    }

    SwigPyIterator& operator -= (ptrdiff_t n)
    {
      return *advance(-n);
    }
      
    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 int init = 0;
      static swig_type_info* desc = 0;
      if (!init) {
	desc = SWIG_TypeQuery("swig::SwigPyIterator *");
	init = 1;
      }	
      return desc;
    }    
  };

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


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 <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 = floor(x);
   double cx = ceil(x);
   double 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));
      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;
}


  #define SWIG_From_long   PyInt_FromLong 


#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);
}


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));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


#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>


#include <list>


#include <utility>


#include <set>


#include <map>


#include <algorithm>


#include <stdint.h>		// Use the C99 official header


#include <iostream>
#include <fstream>
#include <sstream>
#include <signal.h>

#include <spot/misc/common.hh>
#include <spot/misc/version.hh>
#include <spot/misc/minato.hh>
#include <spot/misc/optionmap.hh>
#include <spot/misc/random.hh>
#include <spot/misc/escape.hh>
#include <spot/misc/trival.hh>

#include <spot/tl/formula.hh>

#include <spot/tl/environment.hh>
#include <spot/tl/declenv.hh>
#include <spot/tl/defaultenv.hh>

#include <spot/tl/parse.hh>

#include <spot/twa/bdddict.hh>

#include <spot/tl/apcollect.hh>
#include <spot/tl/contain.hh>
#include <spot/tl/dot.hh>
#include <spot/tl/nenoform.hh>
#include <spot/tl/print.hh>
#include <spot/tl/simplify.hh>
#include <spot/tl/sonf.hh>
#include <spot/tl/unabbrev.hh>
#include <spot/tl/randomltl.hh>
#include <spot/tl/length.hh>
#include <spot/tl/ltlf.hh>
#include <spot/tl/hierarchy.hh>
#include <spot/tl/remove_x.hh>
#include <spot/tl/relabel.hh>

#include <spot/twa/bddprint.hh>
#include <spot/twa/formula2bdd.hh>
#include <spot/twa/fwd.hh>
#include <spot/twa/acc.hh>
#include <spot/twa/twa.hh>
#include <spot/twa/taatgba.hh>
#include <spot/twa/twaproduct.hh>

#include <spot/twaalgos/aiger.hh>
#include <spot/twaalgos/alternation.hh>
#include <spot/twaalgos/cleanacc.hh>
#include <spot/twaalgos/cobuchi.hh>
#include <spot/twaalgos/copy.hh>
#include <spot/twaalgos/complete.hh>
#include <spot/twaalgos/complement.hh>
#include <spot/twaalgos/dbranch.hh>
#include <spot/twaalgos/degen.hh>
#include <spot/twaalgos/dot.hh>
#include <spot/twaalgos/dualize.hh>
#include <spot/twaalgos/emptiness.hh>
#include <spot/twaalgos/gtec/gtec.hh>
#include <spot/twaalgos/genem.hh>
#include <spot/twaalgos/lbtt.hh>
#include <spot/twaalgos/ltl2taa.hh>
#include <spot/twaalgos/ltl2tgba_fm.hh>
#include <spot/twaalgos/gfguarantee.hh>
#include <spot/twaalgos/compsusp.hh>
#include <spot/twaalgos/contains.hh>
#include <spot/twaalgos/determinize.hh>
#include <spot/twaalgos/magic.hh>
#include <spot/twaalgos/minimize.hh>
#include <spot/twaalgos/mealy_machine.hh>
#include <spot/twaalgos/neverclaim.hh>
#include <spot/twaalgos/randomize.hh>
#include <spot/twaalgos/remfin.hh>
#include <spot/twaalgos/remprop.hh>
#include <spot/twaalgos/totgba.hh>
#include <spot/twaalgos/sbacc.hh>
#include <spot/twaalgos/sccinfo.hh>
#include <spot/twaalgos/strength.hh>
#include <spot/twaalgos/sccfilter.hh>
#include <spot/twaalgos/stats.hh>
#include <spot/twaalgos/isdet.hh>
#include <spot/twaalgos/iscolored.hh>
#include <spot/twaalgos/isunamb.hh>
#include <spot/twaalgos/isweakscc.hh>
#include <spot/twaalgos/game.hh>
#include <spot/twaalgos/langmap.hh>
#include <spot/twaalgos/simulation.hh>
#include <spot/twaalgos/split.hh>
#include <spot/twaalgos/sum.hh>
#include <spot/twaalgos/parity.hh>
#include <spot/twaalgos/postproc.hh>
#include <spot/twaalgos/powerset.hh>
#include <spot/twaalgos/product.hh>
#include <spot/twaalgos/stutter.hh>
#include <spot/twaalgos/synthesis.hh>
#include <spot/twaalgos/translate.hh>
#include <spot/twaalgos/toweak.hh>
#include <spot/twaalgos/hoa.hh>
#include <spot/twaalgos/dtwasat.hh>
#include <spot/twaalgos/relabel.hh>
#include <spot/twaalgos/word.hh>
#include <spot/twaalgos/are_isomorphic.hh>
#include <spot/twaalgos/toparity.hh>
#include <spot/twaalgos/zlktree.hh>

#include <spot/parseaut/public.hh>

#include <spot/kripke/fairkripke.hh>
#include <spot/kripke/kripke.hh>
#include <spot/kripke/kripkegraph.hh>

#include <spot/ta/ta.hh>
#include <spot/ta/tgta.hh>
#include <spot/ta/taexplicit.hh>
#include <spot/ta/tgtaexplicit.hh>
#include <spot/taalgos/tgba2ta.hh>
#include <spot/taalgos/dot.hh>
#include <spot/taalgos/stats.hh>
#include <spot/taalgos/minimize.hh>

using namespace spot;


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);
  }
}


#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)
    {
      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)
    {
      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) {
	throw stop_iteration();
      } 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) {
	  throw stop_iteration();
	} 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) {
	  throw stop_iteration();
	} 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<typename OutIterator,
	   typename ValueType =
	   typename std::iterator_traits<OutIterator>::pointer,
	   typename FromOper = from_oper<ValueType> >
  class ForwardIterator_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;

    ForwardIterator_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) {
	throw stop_iteration();
      } else {
	return from(static_cast<value_type>(&*(base::current)));
      }
    }

    SwigPyIterator *copy() const
    {
      return new ForwardIterator_T(*this);
    }

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

  protected:
    out_iterator begin;
    out_iterator end;
  };


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

  // Likewise, but without returning a pointer.
  template<typename OutIterator,
	   typename ValueType =
	   typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class ForwardIterator_T_NP :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;

    ForwardIterator_T_NP(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) {
	throw stop_iteration();
      } else {
	return from(static_cast<value_type>(*(base::current)));
      }
    }

    SwigPyIterator *copy() const
    {
      return new ForwardIterator_T_NP(*this);
    }

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

  protected:
    out_iterator begin;
    out_iterator end;
  };

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


// This function is called whenever an exception has been caught.
// Doing all the conversion in a separate function (rather than
// in the %exception statement) saves a lot of space.
//
// The technique is also called "Lippincott function".
static void handle_any_exception()
{
  try {
    throw;
  }
  catch (const spot::parse_error& e)
  {
    std::string er("\n");
    er += e.what();
    SWIG_Error(SWIG_SyntaxError, er.c_str());
  }
  catch (const std::invalid_argument& e)
  {
    SWIG_Error(SWIG_ValueError, e.what());
  }
  catch (const std::overflow_error& e)
  {
    SWIG_Error(SWIG_OverflowError, e.what());
  }
  catch (const std::out_of_range& e)
  {
    SWIG_Error(SWIG_IndexError, e.what());
  }
  catch (const std::runtime_error& e)
  {
    SWIG_Error(SWIG_RuntimeError, e.what());
  }
}


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


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;
    int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (!alloc && cptr) {
        /* We can't allow converting without allocation, since the internal
           representation of string in Python 3 is UCS-2/UCS-4 but we require
           a UTF-8 representation.
           TODO(bhy) More detailed explanation */
        return SWIG_RuntimeError;
    }
    obj = PyUnicode_AsUTF8String(obj);
    if (!obj)
      return SWIG_TypeError;
    if (alloc)
      *alloc = SWIG_NEWOBJ;
#endif
    if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#else
    if (PyString_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#endif
    if (cptr) {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
	  *alloc = SWIG_NEWOBJ;
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      } else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
	*cptr = PyBytes_AsString(obj);
#else
	assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
	*cptr = SWIG_Python_str_AsChar(obj);
        if (!*cptr)
          ret = SWIG_TypeError;
#endif
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    Py_XDECREF(obj);
#endif
    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;

        Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        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;
}


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 {
    static int init = 0;
    static swig_type_info* descriptor = 0;
    if (!init) {
      descriptor = SWIG_TypeQuery("std::string" " *");
      init = 1;
    }
    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_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);
}


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > INT_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();
  }
}


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


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 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;
}


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


  #define SWIG_From_double   PyFloat_FromDouble 

SWIGINTERN std::string spot_trival___repr__(spot::trival *self){
    if (self->is_true())
      return "spot.trival(True)";
    if (self->is_false())
      return "spot.trival(False)";
    return "spot.trival_maybe()";
  }
SWIGINTERN std::string spot_trival___str__(spot::trival *self){
    std::ostringstream os;
    os << *self;
    return os.str();
  }
SWIGINTERN spot::trival spot_trival___neg__(spot::trival *self){
    return !*self;
  }
SWIGINTERN spot::trival spot_trival___and__(spot::trival *self,spot::trival other){
    return *self && other;
  }
SWIGINTERN spot::trival spot_trival___or__(spot::trival *self,spot::trival other){
    return *self || other;
  }
SWIGINTERN bool spot_trival___eq__(spot::trival *self,spot::trival other){
    return self->val() == other.val();
  }
SWIGINTERN bool spot_trival___ne__(spot::trival *self,spot::trival other){
    return self->val() != other.val();
  }

#include <memory>


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_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


#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 int spot_formula___cmp__(spot::formula *self,spot::formula b){ return self->id() - b.id(); }
SWIGINTERN size_t spot_formula___hash__(spot::formula *self){ return self->id(); }
SWIGINTERN unsigned int spot_formula___len__(spot::formula *self){ return self->size(); }
SWIGINTERN spot::formula spot_formula___getitem__(spot::formula *self,unsigned int pos){ return (*self)[pos]; }
SWIGINTERN std::string spot_formula___repr__(spot::formula *self){
    return "spot.formula(\"" + spot::escape_str(spot::str_psl(*self)) + "\")";
  }
SWIGINTERN std::string spot_formula___str__(spot::formula *self){ return spot::str_psl(*self); }

#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) {
      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];
          sprintf(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];
        sprintf(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 T>
  struct SwigPySequence_Ref
  {
    SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
      : _seq(seq), _index(index)
    {
    }
    
    operator T () const
    {
      swig::SwigVar_PyObject item = PySequence_GetItem(_seq, _index);
      try {
	return swig::as<T>(item);
      } catch (const std::invalid_argument& e) {
	char msg[1024];
	sprintf(msg, "in sequence element %d ", (int)_index);
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
	}
	SWIG_Python_AddErrorMsg(msg);
	SWIG_Python_AddErrorMsg(e.what());
	throw;
      }
    }

    SwigPySequence_Ref& operator=(const T& v)
    {
      PySequence_SetItem(_seq, _index, swig::from<T>(v));
      return *this;
    }

  private:
    PyObject* _seq;
    Py_ssize_t _index;
  };

  template <class T>
  struct SwigPySequence_ArrowProxy
  {
    SwigPySequence_ArrowProxy(const T& x): m_value(x) {}
    const T* operator->() const { return &m_value; }
    operator const T*() const { return &m_value; }
    T m_value;
  };

  template <class T, class Reference >
  struct SwigPySequence_InputIterator
  {
    typedef SwigPySequence_InputIterator<T, Reference > self;

    typedef std::random_access_iterator_tag iterator_category;
    typedef Reference reference;
    typedef T value_type;
    typedef T* pointer;
    typedef Py_ssize_t difference_type;

    SwigPySequence_InputIterator()
    {
    }

    SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
      : _seq(seq), _index(index)
    {
    }

    reference operator*() const
    {
      return reference(_seq, _index);
    }

    SwigPySequence_ArrowProxy<T>
    operator->() const {
      return SwigPySequence_ArrowProxy<T>(operator*());
    }

    bool operator==(const self& ri) const
    {
      return (_index == ri._index) && (_seq == ri._seq);
    }

    bool operator!=(const self& ri) const
    {
      return !(operator==(ri));
    }

    self& operator ++ ()
    {
      ++_index;
      return *this;
    }

    self& operator -- ()
    {
      --_index;
      return *this;
    }

    self& operator += (difference_type n)
    {
      _index += n;
      return *this;
    }

    self operator +(difference_type n) const
    {
      return self(_seq, _index + n);
    }

    self& operator -= (difference_type n)
    {
      _index -= n;
      return *this;
    }

    self operator -(difference_type n) const
    {
      return self(_seq, _index - n);
    }

    difference_type operator - (const self& ri) const
    {
      return _index - ri._index;
    }

    bool operator < (const self& ri) const
    {
      return _index < ri._index;
    }

    reference
    operator[](difference_type n) const
    {
      return reference(_seq, _index + n);
    }

  private:
    PyObject* _seq;
    difference_type _index;
  };

  // STL container wrapper around a Python sequence
  template <class T>
  struct SwigPySequence_Cont
  {
    typedef SwigPySequence_Ref<T> reference;
    typedef const SwigPySequence_Ref<T> const_reference;
    typedef T value_type;
    typedef T* pointer;
    typedef Py_ssize_t difference_type;
    typedef size_t size_type;
    typedef const pointer const_pointer;
    typedef SwigPySequence_InputIterator<T, reference> iterator;
    typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;

    SwigPySequence_Cont(PyObject* seq) : _seq(0)
    {
      if (!PySequence_Check(seq)) {
	throw std::invalid_argument("a sequence is expected");
      }
      _seq = seq;
      Py_INCREF(_seq);
    }

    ~SwigPySequence_Cont()
    {
      Py_XDECREF(_seq);
    }

    size_type size() const
    {
      return static_cast<size_type>(PySequence_Size(_seq));
    }

    bool empty() const
    {
      return size() == 0;
    }

    iterator begin()
    {
      return iterator(_seq, 0);
    }

    const_iterator begin() const
    {
      return const_iterator(_seq, 0);
    }

    iterator end()
    {
      return iterator(_seq, size());
    }

    const_iterator end() const
    {
      return const_iterator(_seq, size());
    }

    reference operator[](difference_type n)
    {
      return reference(_seq, n);
    }

    const_reference operator[](difference_type n)  const
    {
      return const_reference(_seq, n);
    }

    bool check() const
    {
      Py_ssize_t s = size();
      for (Py_ssize_t i = 0; i < s; ++i) {
	swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
	if (!swig::check<value_type>(item))
	  return false;
      }
      return true;
    }

  private:
    PyObject* _seq;
  };

}


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;
}


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 <class SwigPySeq, class Seq>
  inline void
  assign(const SwigPySeq& swigpyseq, Seq* seq) {
    // seq->assign(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
    typedef typename SwigPySeq::value_type value_type;
    typename SwigPySeq::const_iterator it = swigpyseq.begin();
    for (;it != swigpyseq.end(); ++it) {
      seq->insert(seq->end(),(value_type)(*it));
    }
  }

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

    static int asptr(PyObject *obj, sequence **seq) {
      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 (PySequence_Check(obj)) {
	try {
	  SwigPySequence_Cont<value_type> swigpyseq(obj);
	  if (seq) {
	    sequence *pseq = new sequence();
	    assign(swigpyseq, pseq);
	    *seq = pseq;
	    return SWIG_NEWOBJ;
	  } else {
	    return swigpyseq.check() ? SWIG_OK : SWIG_ERROR;
	  }
	} catch (std::exception& e) {
	  if (seq) {
	    if (!PyErr_Occurred()) {
	      PyErr_SetString(PyExc_TypeError, e.what());
	    }
	  }
	  return SWIG_ERROR;
	}
      }
      return SWIG_ERROR;
    }
  };

  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)INT_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_asptr<std::list<T> >  {
      static int asptr(PyObject *obj, std::list<T> **lis) {
	return traits_asptr_stdseq<std::list<T> >::asptr(obj, lis);
      }
    };

    template <class T>
    struct traits_from<std::list<T> > {
      static PyObject *from(const std::list<T>& vec) {
	return traits_from_stdseq<std::list<T> >::from(vec);
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::list< std::string, std::allocator< std::string > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::list<" "std::string" ", " "std::allocator< std::string >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_list_Sl_std_string_Sg__iterator(std::list< std::string > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_list_Sl_std_string_Sg____nonzero__(std::list< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_list_Sl_std_string_Sg____bool__(std::list< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN std::list< std::string >::size_type std_list_Sl_std_string_Sg____len__(std::list< std::string > const *self){
      return self->size();
    }
SWIGINTERN std::list< std::string,std::allocator< std::string > > *std_list_Sl_std_string_Sg____getslice__(std::list< std::string > *self,std::list< std::string >::difference_type i,std::list< std::string >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_list_Sl_std_string_Sg____setslice____SWIG_0(std::list< std::string > *self,std::list< std::string >::difference_type i,std::list< std::string >::difference_type j){
      swig::setslice(self, i, j, 1, std::list< std::string,std::allocator< std::string > >());
    }
SWIGINTERN void std_list_Sl_std_string_Sg____setslice____SWIG_1(std::list< std::string > *self,std::list< std::string >::difference_type i,std::list< std::string >::difference_type j,std::list< std::string,std::allocator< std::string > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_list_Sl_std_string_Sg____delslice__(std::list< std::string > *self,std::list< std::string >::difference_type i,std::list< std::string >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_list_Sl_std_string_Sg____delitem____SWIG_0(std::list< std::string > *self,std::list< std::string >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::list< std::string,std::allocator< std::string > > *std_list_Sl_std_string_Sg____getitem____SWIG_0(std::list< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< std::string,std::allocator< std::string > >::difference_type id = i;
      std::list< std::string,std::allocator< std::string > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_list_Sl_std_string_Sg____setitem____SWIG_0(std::list< std::string > *self,PySliceObject *slice,std::list< 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(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< std::string,std::allocator< std::string > >::difference_type id = i;
      std::list< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_list_Sl_std_string_Sg____setitem____SWIG_1(std::list< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< std::string,std::allocator< std::string > >::difference_type id = i;
      std::list< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_list_Sl_std_string_Sg____delitem____SWIG_1(std::list< std::string > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< std::string,std::allocator< std::string > >::difference_type id = i;
      std::list< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::list< std::string >::value_type const &std_list_Sl_std_string_Sg____getitem____SWIG_1(std::list< std::string > const *self,std::list< std::string >::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_list_Sl_std_string_Sg____setitem____SWIG_2(std::list< std::string > *self,std::list< std::string >::difference_type i,std::list< std::string >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::list< std::string >::value_type std_list_Sl_std_string_Sg__pop(std::list< std::string > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::list< std::string,std::allocator< std::string > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_list_Sl_std_string_Sg__append(std::list< std::string > *self,std::list< std::string >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::list< std::string >::iterator std_list_Sl_std_string_Sg__erase__SWIG_0(std::list< std::string > *self,std::list< std::string >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::list< std::string >::iterator std_list_Sl_std_string_Sg__erase__SWIG_1(std::list< std::string > *self,std::list< std::string >::iterator first,std::list< std::string >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::list< std::string >::iterator std_list_Sl_std_string_Sg__insert__SWIG_0(std::list< std::string > *self,std::list< std::string >::iterator pos,std::list< std::string >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_list_Sl_std_string_Sg__insert__SWIG_1(std::list< std::string > *self,std::list< std::string >::iterator pos,std::list< std::string >::size_type n,std::list< std::string >::value_type const &x){ self->insert(pos, n, x); }

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 <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< unsigned int, unsigned int > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "unsigned int" "," "unsigned int" " >";
	  }
	};
      }
    

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


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

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);
    }
  };
}


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


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

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


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

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


  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< spot::formula, std::allocator< spot::formula > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "spot::formula" "," "std::allocator< spot::formula >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_spot_formula_Sg__iterator(std::vector< spot::formula > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_spot_formula_Sg____nonzero__(std::vector< spot::formula > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_spot_formula_Sg____bool__(std::vector< spot::formula > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< spot::formula >::size_type std_vector_Sl_spot_formula_Sg____len__(std::vector< spot::formula > const *self){
      return self->size();
    }
SWIGINTERN std::vector< spot::formula,std::allocator< spot::formula > > *std_vector_Sl_spot_formula_Sg____getslice__(std::vector< spot::formula > *self,std::vector< spot::formula >::difference_type i,std::vector< spot::formula >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_formula_Sg____setslice____SWIG_0(std::vector< spot::formula > *self,std::vector< spot::formula >::difference_type i,std::vector< spot::formula >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< spot::formula,std::allocator< spot::formula > >());
    }
SWIGINTERN void std_vector_Sl_spot_formula_Sg____setslice____SWIG_1(std::vector< spot::formula > *self,std::vector< spot::formula >::difference_type i,std::vector< spot::formula >::difference_type j,std::vector< spot::formula,std::allocator< spot::formula > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_spot_formula_Sg____delslice__(std::vector< spot::formula > *self,std::vector< spot::formula >::difference_type i,std::vector< spot::formula >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_formula_Sg____delitem____SWIG_0(std::vector< spot::formula > *self,std::vector< spot::formula >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< spot::formula,std::allocator< spot::formula > > *std_vector_Sl_spot_formula_Sg____getitem____SWIG_0(std::vector< spot::formula > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::formula,std::allocator< spot::formula > >::difference_type id = i;
      std::vector< spot::formula,std::allocator< spot::formula > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_formula_Sg____setitem____SWIG_0(std::vector< spot::formula > *self,PySliceObject *slice,std::vector< spot::formula,std::allocator< spot::formula > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::formula,std::allocator< spot::formula > >::difference_type id = i;
      std::vector< spot::formula,std::allocator< spot::formula > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_spot_formula_Sg____setitem____SWIG_1(std::vector< spot::formula > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::formula,std::allocator< spot::formula > >::difference_type id = i;
      std::vector< spot::formula,std::allocator< spot::formula > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_formula_Sg____delitem____SWIG_1(std::vector< spot::formula > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::formula,std::allocator< spot::formula > >::difference_type id = i;
      std::vector< spot::formula,std::allocator< spot::formula > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< spot::formula >::value_type const &std_vector_Sl_spot_formula_Sg____getitem____SWIG_1(std::vector< spot::formula > const *self,std::vector< spot::formula >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_spot_formula_Sg____setitem____SWIG_2(std::vector< spot::formula > *self,std::vector< spot::formula >::difference_type i,std::vector< spot::formula >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< spot::formula >::value_type std_vector_Sl_spot_formula_Sg__pop(std::vector< spot::formula > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< spot::formula,std::allocator< spot::formula > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_spot_formula_Sg__append(std::vector< spot::formula > *self,std::vector< spot::formula >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< spot::formula >::iterator std_vector_Sl_spot_formula_Sg__erase__SWIG_0(std::vector< spot::formula > *self,std::vector< spot::formula >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< spot::formula >::iterator std_vector_Sl_spot_formula_Sg__erase__SWIG_1(std::vector< spot::formula > *self,std::vector< spot::formula >::iterator first,std::vector< spot::formula >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< spot::formula >::iterator std_vector_Sl_spot_formula_Sg__insert__SWIG_0(std::vector< spot::formula > *self,std::vector< spot::formula >::iterator pos,std::vector< spot::formula >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_spot_formula_Sg__insert__SWIG_1(std::vector< spot::formula > *self,std::vector< spot::formula >::iterator pos,std::vector< spot::formula >::size_type n,std::vector< spot::formula >::value_type const &x){ self->insert(pos, n, x); }

      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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(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::pair< unsigned int,unsigned int >, std::allocator< std::pair< unsigned int,unsigned int > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::pair< unsigned int,unsigned int >" "," "std::allocator< std::pair< unsigned int,unsigned int > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__iterator(std::vector< std::pair< unsigned int,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_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____nonzero__(std::vector< std::pair< unsigned int,unsigned int > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____bool__(std::vector< std::pair< unsigned int,unsigned int > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::size_type std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____len__(std::vector< std::pair< unsigned int,unsigned int > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____getslice__(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i,std::vector< std::pair< unsigned int,unsigned int > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setslice____SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i,std::vector< std::pair< unsigned int,unsigned int > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >());
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setslice____SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i,std::vector< std::pair< unsigned int,unsigned int > >::difference_type j,std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____delslice__(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i,std::vector< std::pair< unsigned int,unsigned int > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type id = i;
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,PySliceObject *slice,std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type id = i;
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type id = i;
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type id = i;
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::value_type const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____getitem____SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > const *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_2(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::difference_type i,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::value_type std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__pop(std::vector< std::pair< unsigned int,unsigned int > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__append(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::iterator std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__erase__SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::iterator std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__erase__SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::iterator first,std::vector< std::pair< unsigned int,unsigned int > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int > >::iterator std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__insert__SWIG_0(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::iterator pos,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__insert__SWIG_1(std::vector< std::pair< unsigned int,unsigned int > > *self,std::vector< std::pair< unsigned int,unsigned int > >::iterator pos,std::vector< std::pair< unsigned int,unsigned int > >::size_type n,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< spot::acc_cond, std::allocator< spot::acc_cond > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "spot::acc_cond" "," "std::allocator< spot::acc_cond >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_spot_acc_cond_Sg__iterator(std::vector< spot::acc_cond > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_spot_acc_cond_Sg____nonzero__(std::vector< spot::acc_cond > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_spot_acc_cond_Sg____bool__(std::vector< spot::acc_cond > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< spot::acc_cond >::size_type std_vector_Sl_spot_acc_cond_Sg____len__(std::vector< spot::acc_cond > const *self){
      return self->size();
    }
SWIGINTERN std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *std_vector_Sl_spot_acc_cond_Sg____getslice__(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::difference_type i,std::vector< spot::acc_cond >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_Sg____setslice____SWIG_0(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::difference_type i,std::vector< spot::acc_cond >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >());
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_Sg____setslice____SWIG_1(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::difference_type i,std::vector< spot::acc_cond >::difference_type j,std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_Sg____delslice__(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::difference_type i,std::vector< spot::acc_cond >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_Sg____delitem____SWIG_0(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *std_vector_Sl_spot_acc_cond_Sg____getitem____SWIG_0(std::vector< spot::acc_cond > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >::difference_type id = i;
      std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_Sg____setitem____SWIG_0(std::vector< spot::acc_cond > *self,PySliceObject *slice,std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >::difference_type id = i;
      std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_Sg____setitem____SWIG_1(std::vector< spot::acc_cond > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >::difference_type id = i;
      std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_Sg____delitem____SWIG_1(std::vector< spot::acc_cond > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >::difference_type id = i;
      std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< spot::acc_cond >::value_type const &std_vector_Sl_spot_acc_cond_Sg____getitem____SWIG_1(std::vector< spot::acc_cond > const *self,std::vector< spot::acc_cond >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_Sg____setitem____SWIG_2(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::difference_type i,std::vector< spot::acc_cond >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< spot::acc_cond >::value_type std_vector_Sl_spot_acc_cond_Sg__pop(std::vector< spot::acc_cond > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_Sg__append(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< spot::acc_cond >::iterator std_vector_Sl_spot_acc_cond_Sg__erase__SWIG_0(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< spot::acc_cond >::iterator std_vector_Sl_spot_acc_cond_Sg__erase__SWIG_1(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::iterator first,std::vector< spot::acc_cond >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< spot::acc_cond >::iterator std_vector_Sl_spot_acc_cond_Sg__insert__SWIG_0(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::iterator pos,std::vector< spot::acc_cond >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_spot_acc_cond_Sg__insert__SWIG_1(std::vector< spot::acc_cond > *self,std::vector< spot::acc_cond >::iterator pos,std::vector< spot::acc_cond >::size_type n,std::vector< spot::acc_cond >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< spot::acc_cond::acc_code, std::allocator< spot::acc_cond::acc_code > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "spot::acc_cond::acc_code" "," "std::allocator< spot::acc_cond::acc_code >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_spot_acc_cond_acc_code_Sg__iterator(std::vector< spot::acc_cond::acc_code > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_spot_acc_cond_acc_code_Sg____nonzero__(std::vector< spot::acc_cond::acc_code > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_spot_acc_cond_acc_code_Sg____bool__(std::vector< spot::acc_cond::acc_code > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< spot::acc_cond::acc_code >::size_type std_vector_Sl_spot_acc_cond_acc_code_Sg____len__(std::vector< spot::acc_cond::acc_code > const *self){
      return self->size();
    }
SWIGINTERN std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *std_vector_Sl_spot_acc_cond_acc_code_Sg____getslice__(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::difference_type i,std::vector< spot::acc_cond::acc_code >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_acc_code_Sg____setslice____SWIG_0(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::difference_type i,std::vector< spot::acc_cond::acc_code >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >());
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_acc_code_Sg____setslice____SWIG_1(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::difference_type i,std::vector< spot::acc_cond::acc_code >::difference_type j,std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_acc_code_Sg____delslice__(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::difference_type i,std::vector< spot::acc_cond::acc_code >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_acc_code_Sg____delitem____SWIG_0(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *std_vector_Sl_spot_acc_cond_acc_code_Sg____getitem____SWIG_0(std::vector< spot::acc_cond::acc_code > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >::difference_type id = i;
      std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_acc_code_Sg____setitem____SWIG_0(std::vector< spot::acc_cond::acc_code > *self,PySliceObject *slice,std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >::difference_type id = i;
      std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_acc_code_Sg____setitem____SWIG_1(std::vector< spot::acc_cond::acc_code > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >::difference_type id = i;
      std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_acc_code_Sg____delitem____SWIG_1(std::vector< spot::acc_cond::acc_code > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >::difference_type id = i;
      std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< spot::acc_cond::acc_code >::value_type const &std_vector_Sl_spot_acc_cond_acc_code_Sg____getitem____SWIG_1(std::vector< spot::acc_cond::acc_code > const *self,std::vector< spot::acc_cond::acc_code >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_acc_code_Sg____setitem____SWIG_2(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::difference_type i,std::vector< spot::acc_cond::acc_code >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< spot::acc_cond::acc_code >::value_type std_vector_Sl_spot_acc_cond_acc_code_Sg__pop(std::vector< spot::acc_cond::acc_code > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_acc_code_Sg__append(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< spot::acc_cond::acc_code >::iterator std_vector_Sl_spot_acc_cond_acc_code_Sg__erase__SWIG_0(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< spot::acc_cond::acc_code >::iterator std_vector_Sl_spot_acc_cond_acc_code_Sg__erase__SWIG_1(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::iterator first,std::vector< spot::acc_cond::acc_code >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< spot::acc_cond::acc_code >::iterator std_vector_Sl_spot_acc_cond_acc_code_Sg__insert__SWIG_0(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::iterator pos,std::vector< spot::acc_cond::acc_code >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_spot_acc_cond_acc_code_Sg__insert__SWIG_1(std::vector< spot::acc_cond::acc_code > *self,std::vector< spot::acc_cond::acc_code >::iterator pos,std::vector< spot::acc_cond::acc_code >::size_type n,std::vector< spot::acc_cond::acc_code >::value_type const &x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector<bool, std::allocator< bool > > > {
	  typedef value_category category;
	  static const char* type_name() {
	    return "std::vector<bool, std::allocator< bool > >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_bool_Sg__iterator(std::vector< bool > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_bool_Sg____nonzero__(std::vector< bool > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_bool_Sg____bool__(std::vector< bool > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< bool >::size_type std_vector_Sl_bool_Sg____len__(std::vector< bool > const *self){
      return self->size();
    }
SWIGINTERN std::vector< bool,std::allocator< bool > > *std_vector_Sl_bool_Sg____getslice__(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setslice____SWIG_0(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector<bool,std::allocator< bool > >());
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setslice____SWIG_1(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j,std::vector< bool,std::allocator< bool > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____delslice__(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____delitem____SWIG_0(std::vector< bool > *self,std::vector< bool >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< bool,std::allocator< bool > > *std_vector_Sl_bool_Sg____getitem____SWIG_0(std::vector< bool > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_0(std::vector< bool > *self,PySliceObject *slice,std::vector< bool,std::allocator< bool > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_1(std::vector< bool > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_bool_Sg____delitem____SWIG_1(std::vector< bool > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector<bool,std::allocator< bool > >::difference_type id = i;
      std::vector<bool,std::allocator< bool > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< bool >::value_type std_vector_Sl_bool_Sg____getitem____SWIG_1(std::vector< bool > *self,std::vector< bool >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_bool_Sg____setitem____SWIG_2(std::vector< bool > *self,std::vector< bool >::difference_type i,std::vector< bool >::value_type x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< bool >::value_type std_vector_Sl_bool_Sg__pop(std::vector< bool > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector<bool,std::allocator< bool > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_bool_Sg__append(std::vector< bool > *self,std::vector< bool >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__erase__SWIG_0(std::vector< bool > *self,std::vector< bool >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__erase__SWIG_1(std::vector< bool > *self,std::vector< bool >::iterator first,std::vector< bool >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< bool >::iterator std_vector_Sl_bool_Sg__insert__SWIG_0(std::vector< bool > *self,std::vector< bool >::iterator pos,std::vector< bool >::value_type x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_bool_Sg__insert__SWIG_1(std::vector< bool > *self,std::vector< bool >::iterator pos,std::vector< bool >::size_type n,std::vector< bool >::value_type x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector< bdd, std::allocator< bdd > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "bdd" "," "std::allocator< bdd >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_bdd_Sg__iterator(std::vector< bdd > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_bdd_Sg____nonzero__(std::vector< bdd > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_bdd_Sg____bool__(std::vector< bdd > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< bdd >::size_type std_vector_Sl_bdd_Sg____len__(std::vector< bdd > const *self){
      return self->size();
    }
SWIGINTERN std::vector< bdd,std::allocator< bdd > > *std_vector_Sl_bdd_Sg____getslice__(std::vector< bdd > *self,std::vector< bdd >::difference_type i,std::vector< bdd >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_bdd_Sg____setslice____SWIG_0(std::vector< bdd > *self,std::vector< bdd >::difference_type i,std::vector< bdd >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< bdd,std::allocator< bdd > >());
    }
SWIGINTERN void std_vector_Sl_bdd_Sg____setslice____SWIG_1(std::vector< bdd > *self,std::vector< bdd >::difference_type i,std::vector< bdd >::difference_type j,std::vector< bdd,std::allocator< bdd > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_bdd_Sg____delslice__(std::vector< bdd > *self,std::vector< bdd >::difference_type i,std::vector< bdd >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_bdd_Sg____delitem____SWIG_0(std::vector< bdd > *self,std::vector< bdd >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< bdd,std::allocator< bdd > > *std_vector_Sl_bdd_Sg____getitem____SWIG_0(std::vector< bdd > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< bdd,std::allocator< bdd > >::difference_type id = i;
      std::vector< bdd,std::allocator< bdd > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_bdd_Sg____setitem____SWIG_0(std::vector< bdd > *self,PySliceObject *slice,std::vector< bdd,std::allocator< bdd > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< bdd,std::allocator< bdd > >::difference_type id = i;
      std::vector< bdd,std::allocator< bdd > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_bdd_Sg____setitem____SWIG_1(std::vector< bdd > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< bdd,std::allocator< bdd > >::difference_type id = i;
      std::vector< bdd,std::allocator< bdd > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_bdd_Sg____delitem____SWIG_1(std::vector< bdd > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< bdd,std::allocator< bdd > >::difference_type id = i;
      std::vector< bdd,std::allocator< bdd > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< bdd >::value_type const &std_vector_Sl_bdd_Sg____getitem____SWIG_1(std::vector< bdd > const *self,std::vector< bdd >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_bdd_Sg____setitem____SWIG_2(std::vector< bdd > *self,std::vector< bdd >::difference_type i,std::vector< bdd >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< bdd >::value_type std_vector_Sl_bdd_Sg__pop(std::vector< bdd > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< bdd,std::allocator< bdd > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_bdd_Sg__append(std::vector< bdd > *self,std::vector< bdd >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< bdd >::iterator std_vector_Sl_bdd_Sg__erase__SWIG_0(std::vector< bdd > *self,std::vector< bdd >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< bdd >::iterator std_vector_Sl_bdd_Sg__erase__SWIG_1(std::vector< bdd > *self,std::vector< bdd >::iterator first,std::vector< bdd >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< bdd >::iterator std_vector_Sl_bdd_Sg__insert__SWIG_0(std::vector< bdd > *self,std::vector< bdd >::iterator pos,std::vector< bdd >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_bdd_Sg__insert__SWIG_1(std::vector< bdd > *self,std::vector< bdd >::iterator pos,std::vector< bdd >::size_type n,std::vector< bdd >::value_type const &x){ self->insert(pos, n, x); }

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


      namespace swig {
	template <>  struct traits<std::vector< std::pair< std::string,bdd >, std::allocator< std::pair< std::string,bdd > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::pair< std::string,bdd >" "," "std::allocator< std::pair< std::string,bdd > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__iterator(std::vector< std::pair< std::string,bdd > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____nonzero__(std::vector< std::pair< std::string,bdd > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____bool__(std::vector< std::pair< std::string,bdd > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::pair< std::string,bdd > >::size_type std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____len__(std::vector< std::pair< std::string,bdd > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____getslice__(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::difference_type i,std::vector< std::pair< std::string,bdd > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____setslice____SWIG_0(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::difference_type i,std::vector< std::pair< std::string,bdd > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >());
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____setslice____SWIG_1(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::difference_type i,std::vector< std::pair< std::string,bdd > >::difference_type j,std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____delslice__(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::difference_type i,std::vector< std::pair< std::string,bdd > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____delitem____SWIG_0(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____getitem____SWIG_0(std::vector< std::pair< std::string,bdd > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >::difference_type id = i;
      std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____setitem____SWIG_0(std::vector< std::pair< std::string,bdd > > *self,PySliceObject *slice,std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >::difference_type id = i;
      std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____setitem____SWIG_1(std::vector< std::pair< std::string,bdd > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >::difference_type id = i;
      std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____delitem____SWIG_1(std::vector< std::pair< std::string,bdd > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >::difference_type id = i;
      std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::pair< std::string,bdd > >::value_type const &std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____getitem____SWIG_1(std::vector< std::pair< std::string,bdd > > const *self,std::vector< std::pair< std::string,bdd > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____setitem____SWIG_2(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::difference_type i,std::vector< std::pair< std::string,bdd > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::pair< std::string,bdd > >::value_type std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__pop(std::vector< std::pair< std::string,bdd > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__append(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::pair< std::string,bdd > >::iterator std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__erase__SWIG_0(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::pair< std::string,bdd > >::iterator std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__erase__SWIG_1(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::iterator first,std::vector< std::pair< std::string,bdd > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::pair< std::string,bdd > >::iterator std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__insert__SWIG_0(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::iterator pos,std::vector< std::pair< std::string,bdd > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__insert__SWIG_1(std::vector< std::pair< std::string,bdd > > *self,std::vector< std::pair< std::string,bdd > >::iterator pos,std::vector< std::pair< std::string,bdd > >::size_type n,std::vector< std::pair< std::string,bdd > >::value_type const &x){ self->insert(pos, n, x); }

      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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(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); }

      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();
    }
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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(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,PySliceObject *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(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(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,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(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));
    }
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); }

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

  namespace swig {
    template <class SwigPySeq, class T> 
    inline void 
    assign(const SwigPySeq& swigpyseq, std::set<T>* seq) {
      // seq->insert(swigpyseq.begin(), swigpyseq.end()); // not used as not always implemented
      typedef typename SwigPySeq::value_type value_type;
      typename SwigPySeq::const_iterator it = swigpyseq.begin();
      for (;it != swigpyseq.end(); ++it) {
	seq->insert(seq->end(),(value_type)(*it));
      }
    }

    template <class T>
    struct traits_asptr<std::set<T> >  {
      static int asptr(PyObject *obj, std::set<T> **s) {
	return traits_asptr_stdseq<std::set<T> >::asptr(obj, s);
      }
    };

    template <class T>
    struct traits_from<std::set<T> > {
      static PyObject *from(const std::set<T>& vec) {
	return traits_from_stdseq<std::set<T> >::from(vec);
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::set< spot::formula, std::less< spot::formula >, std::allocator< spot::formula > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::set<" "spot::formula" "," "std::less< spot::formula >" "," "std::allocator< spot::formula >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_set_Sl_spot_formula_Sg__iterator(std::set< spot::formula > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_set_Sl_spot_formula_Sg____nonzero__(std::set< spot::formula > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_set_Sl_spot_formula_Sg____bool__(std::set< spot::formula > const *self){
      return !(self->empty());
    }
SWIGINTERN std::set< spot::formula >::size_type std_set_Sl_spot_formula_Sg____len__(std::set< spot::formula > const *self){
      return self->size();
    }
SWIGINTERN void std_set_Sl_spot_formula_Sg__append(std::set< spot::formula > *self,std::set< spot::formula >::value_type x){
       self->insert(x);
     }
SWIGINTERN bool std_set_Sl_spot_formula_Sg____contains__(std::set< spot::formula > *self,std::set< spot::formula >::value_type x){
       return self->find(x) != self->end();
     }
SWIGINTERN std::set< spot::formula >::value_type std_set_Sl_spot_formula_Sg____getitem__(std::set< spot::formula > const *self,std::set< spot::formula >::difference_type i){
       return *(swig::cgetpos(self, i));
     }
SWIGINTERN void std_set_Sl_spot_formula_Sg__add(std::set< spot::formula > *self,std::set< spot::formula >::value_type x){
       self->insert(x);
     }
SWIGINTERN void std_set_Sl_spot_formula_Sg__discard(std::set< spot::formula > *self,std::set< spot::formula >::value_type x){
       self->erase(x);
     }
SWIGINTERN void std_set_Sl_spot_formula_Sg__erase__SWIG_1(std::set< spot::formula > *self,std::set< spot::formula >::iterator pos){ self->erase(pos); }
SWIGINTERN void std_set_Sl_spot_formula_Sg__erase__SWIG_2(std::set< spot::formula > *self,std::set< spot::formula >::iterator first,std::set< spot::formula >::iterator last){ self->erase(first, last); }

SWIGINTERN std::string std_set_Sl_spot_formula_Sg____str__(std::set< spot::formula > *self){
    std::ostringstream os;
    os << '{';
    const char* sep = "";
    for (spot::formula s: *self)
      {
        os << sep << '"' << spot::escape_str(spot::str_psl(s)) << '"';
        sep = ", ";
      }
    os << '}';
    return os.str();
  }
SWIGINTERN std::string std_set_Sl_spot_formula_Sg____repr__(std::set< spot::formula > *self){
    std::ostringstream os;
    os << "spot.atomic_prop_set([";
    const char* sep = "";
    for (spot::formula s: *self)
      {
        os << sep
           << "spot.formula(\"" << spot::escape_str(spot::str_psl(s)) << "\")";
        sep = ", ";
      }
    os << "])";
    return os.str();
  }

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

  namespace swig {
    template <class ValueType>
    struct from_key_oper 
    {
      typedef const ValueType& argument_type;
      typedef  PyObject *result_type;
      result_type operator()(argument_type v) const
      {
	return swig::from(v.first);
      }
    };

    template <class ValueType>
    struct from_value_oper 
    {
      typedef const ValueType& argument_type;
      typedef  PyObject *result_type;
      result_type operator()(argument_type v) const
      {
	return swig::from(v.second);
      }
    };

    template<class OutIterator, class FromOper, class ValueType = typename OutIterator::value_type>
    struct SwigPyMapIterator_T : SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper>
    {
      SwigPyMapIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
	: SwigPyIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
      {
      }
    };


    template<class OutIterator,
	     class FromOper = from_key_oper<typename OutIterator::value_type> >
    struct SwigPyMapKeyIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
    {
      SwigPyMapKeyIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
      {
      }
    };

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

    template<class OutIterator,
	     class FromOper = from_value_oper<typename OutIterator::value_type> >
    struct SwigPyMapValueIterator_T : SwigPyMapIterator_T<OutIterator, FromOper>
    {
      SwigPyMapValueIterator_T(OutIterator curr, OutIterator first, OutIterator last, PyObject *seq)
	: SwigPyMapIterator_T<OutIterator, FromOper>(curr, first, last, seq)
      {
      }
    };
    

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


  namespace swig {
    template <class SwigPySeq, class K, class T, class Compare, class Alloc >
    inline void
    assign(const SwigPySeq& swigpyseq, std::map<K,T,Compare,Alloc > *map) {
      typedef typename std::map<K,T,Compare,Alloc >::value_type value_type;
      typename SwigPySeq::const_iterator it = swigpyseq.begin();
      for (;it != swigpyseq.end(); ++it) {
	map->insert(value_type(it->first, it->second));
      }
    }

    template <class K, class T, class Compare, class Alloc>
    struct traits_asptr<std::map<K,T,Compare,Alloc > >  {
      typedef std::map<K,T,Compare,Alloc > map_type;
      static int asptr(PyObject *obj, map_type **val) {
	int res = SWIG_ERROR;
	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
	if (PyDict_Check(obj)) {
	  SwigVar_PyObject items = PyObject_CallMethod(obj,(char *)"items",NULL);
#if PY_VERSION_HEX >= 0x03000000
          /* In Python 3.x the ".items()" method returns a dict_items object */
          items = PySequence_Fast(items, ".items() didn't return a sequence!");
#endif
	  res = traits_asptr_stdseq<map_type, std::pair<K, T> >::asptr(items, val);
	} else {
	  map_type *p = 0;
	  swig_type_info *descriptor = swig::type_info<map_type>();
	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
	  if (SWIG_IsOK(res) && val)  *val = p;
	}
	SWIG_PYTHON_THREAD_END_BLOCK;
	return res;
      }      
    };
      
    template <class K, class T, class Compare, class Alloc >
    struct traits_from<std::map<K,T,Compare,Alloc > >  {
      typedef std::map<K,T,Compare,Alloc > map_type;
      typedef typename map_type::const_iterator const_iterator;
      typedef typename map_type::size_type size_type;

      static PyObject *asdict(const map_type& map) {
	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
	size_type size = map.size();
	Py_ssize_t pysize = (size <= (size_type) INT_MAX) ? (Py_ssize_t) size : -1;
	if (pysize < 0) {
	  PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	  SWIG_PYTHON_THREAD_END_BLOCK;
	  return NULL;
	}
	PyObject *obj = PyDict_New();
	for (const_iterator i= map.begin(); i!= map.end(); ++i) {
	  swig::SwigVar_PyObject key = swig::from(i->first);
	  swig::SwigVar_PyObject val = swig::from(i->second);
	  PyDict_SetItem(obj, key, val);
	}
	SWIG_PYTHON_THREAD_END_BLOCK;
	return obj;
      }
                
      static PyObject *from(const map_type& map) {
	swig_type_info *desc = swig::type_info<map_type>();
	if (desc && desc->clientdata) {
	  return SWIG_InternalNewPointerObj(new map_type(map), desc, SWIG_POINTER_OWN);
	} else {
	  return asdict(map);
	}
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::map< spot::formula, spot::formula, std::less< spot::formula >, std::allocator< std::pair< spot::formula const,spot::formula > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::map<" "spot::formula" "," "spot::formula" "," "std::less< spot::formula >" "," "std::allocator< std::pair< spot::formula const,spot::formula > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_map_Sl_spot_formula_Sc_spot_formula_Sg__iterator(std::map< spot::formula,spot::formula > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_map_Sl_spot_formula_Sc_spot_formula_Sg____nonzero__(std::map< spot::formula,spot::formula > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_map_Sl_spot_formula_Sc_spot_formula_Sg____bool__(std::map< spot::formula,spot::formula > const *self){
      return !(self->empty());
    }
SWIGINTERN std::map< spot::formula,spot::formula >::size_type std_map_Sl_spot_formula_Sc_spot_formula_Sg____len__(std::map< spot::formula,spot::formula > const *self){
      return self->size();
    }
SWIGINTERN std::map< spot::formula,spot::formula >::mapped_type const &std_map_Sl_spot_formula_Sc_spot_formula_Sg____getitem__(std::map< spot::formula,spot::formula > *self,std::map< spot::formula,spot::formula >::key_type const &key){
      std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::const_iterator i = self->find(key);
      if (i != self->end())
	return i->second;
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN void std_map_Sl_spot_formula_Sc_spot_formula_Sg____delitem__(std::map< spot::formula,spot::formula > *self,std::map< spot::formula,spot::formula >::key_type const &key){
      std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::iterator i = self->find(key);
      if (i != self->end())
	self->erase(i);
      else
	throw std::out_of_range("key not found");
    }
SWIGINTERN bool std_map_Sl_spot_formula_Sc_spot_formula_Sg__has_key(std::map< spot::formula,spot::formula > const *self,std::map< spot::formula,spot::formula >::key_type const &key){
      std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::const_iterator i = self->find(key);
      return i != self->end();
    }
SWIGINTERN PyObject *std_map_Sl_spot_formula_Sc_spot_formula_Sg__keys(std::map< spot::formula,spot::formula > *self){
      std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* keyList = PyList_New(pysize);
      std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(keyList, j, swig::from(i->first));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return keyList;
    }
SWIGINTERN PyObject *std_map_Sl_spot_formula_Sc_spot_formula_Sg__values(std::map< spot::formula,spot::formula > *self){
      std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }
      PyObject* valList = PyList_New(pysize);
      std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(valList, j, swig::from(i->second));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return valList;
    }
SWIGINTERN PyObject *std_map_Sl_spot_formula_Sc_spot_formula_Sg__items(std::map< spot::formula,spot::formula > *self){
      std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::size_type size = self->size();
      Py_ssize_t pysize = (size <= (std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::size_type) INT_MAX) ? (Py_ssize_t) size : -1;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      if (pysize < 0) {
	PyErr_SetString(PyExc_OverflowError, "map size not valid in python");
	SWIG_PYTHON_THREAD_END_BLOCK;
	return NULL;
      }    
      PyObject* itemList = PyList_New(pysize);
      std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > >::const_iterator i = self->begin();
      for (Py_ssize_t j = 0; j < pysize; ++i, ++j) {
	PyList_SET_ITEM(itemList, j, swig::from(*i));
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return itemList;
    }
SWIGINTERN bool std_map_Sl_spot_formula_Sc_spot_formula_Sg____contains__(std::map< spot::formula,spot::formula > *self,std::map< spot::formula,spot::formula >::key_type const &key){
      return self->find(key) != self->end();
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_spot_formula_Sc_spot_formula_Sg__key_iterator(std::map< spot::formula,spot::formula > *self,PyObject **PYTHON_SELF){
      return swig::make_output_key_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN swig::SwigPyIterator *std_map_Sl_spot_formula_Sc_spot_formula_Sg__value_iterator(std::map< spot::formula,spot::formula > *self,PyObject **PYTHON_SELF){
      return swig::make_output_value_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN void std_map_Sl_spot_formula_Sc_spot_formula_Sg____setitem____SWIG_0(std::map< spot::formula,spot::formula > *self,std::map< spot::formula,spot::formula >::key_type const &key){
      self->erase(key);
    }
SWIGINTERN void std_map_Sl_spot_formula_Sc_spot_formula_Sg____setitem____SWIG_1(std::map< spot::formula,spot::formula > *self,std::map< spot::formula,spot::formula >::key_type const &key,std::map< spot::formula,spot::formula >::mapped_type const &x){
      (*self)[key] = x;
    }
SWIGINTERN PyObject *std_map_Sl_spot_formula_Sc_spot_formula_Sg__asdict(std::map< spot::formula,spot::formula > *self){
      return swig::traits_from< std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > > >::asdict(*self);
    }
SWIGINTERN void std_map_Sl_spot_formula_Sc_spot_formula_Sg__erase__SWIG_1(std::map< spot::formula,spot::formula > *self,std::map< spot::formula,spot::formula >::iterator position){ self->erase(position); }
SWIGINTERN void std_map_Sl_spot_formula_Sc_spot_formula_Sg__erase__SWIG_2(std::map< spot::formula,spot::formula > *self,std::map< spot::formula,spot::formula >::iterator first,std::map< spot::formula,spot::formula >::iterator last){ self->erase(first, last); }
SWIGINTERN bool spot_parse_error_list___nonzero__(spot::parse_error_list *self){
  return !self->empty();
}
SWIGINTERN bool spot_parse_error_list___bool__(spot::parse_error_list *self){
  return !self->empty();
}

struct SWIG_null_deleter {
  void operator() (void const *) const {
  }
};
#define SWIG_NO_NULL_DELETER_0 , SWIG_null_deleter()
#define SWIG_NO_NULL_DELETER_1
#define SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW
#define SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN


#define SWIG_NO_NULL_DELETER_SWIG_BUILTIN_INIT

SWIGINTERN bool spot_bdd_dict_operator_Se__Se_(spot::bdd_dict const *self,spot::bdd_dict const &b){
    return self == &b;
  }
SWIGINTERN bool spot_bdd_dict_operator_SN__Se_(spot::bdd_dict const *self,spot::bdd_dict const &b){
    return self != &b;
  }
SWIGINTERN int spot_bdd_dict_register_proposition__SWIG_2(spot::bdd_dict *self,spot::formula f,PyObject *for_me){
    return self->register_proposition(f, ptr_for_bdddict(for_me));
  }
SWIGINTERN void spot_bdd_dict_unregister_all_my_variables__SWIG_1(spot::bdd_dict *self,PyObject *me){
    return self->unregister_all_my_variables(ptr_for_bdddict(me));
  }
SWIGINTERN void spot_bdd_dict_unregister_variable__SWIG_2(spot::bdd_dict *self,int var,PyObject *me){
    return self->unregister_variable(var, ptr_for_bdddict(me));
  }
SWIGINTERN void spot_bdd_dict_register_all_variables_of__SWIG_4(spot::bdd_dict *self,PyObject *from_other,PyObject *for_me){
    return self->register_all_variables_of(ptr_for_bdddict(from_other),
                                            ptr_for_bdddict(for_me));
  }
SWIGINTERN int spot_bdd_dict_register_anonymous_variables__SWIG_2(spot::bdd_dict *self,int n,PyObject *for_me){
    return self->register_anonymous_variables(n, ptr_for_bdddict(for_me));
  }

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


      namespace swig {
	template <>  struct traits<std::vector< spot::acc_cond::rs_pair, std::allocator< spot::acc_cond::rs_pair > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "spot::acc_cond::rs_pair" "," "std::allocator< spot::acc_cond::rs_pair >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_spot_acc_cond_rs_pair_Sg__iterator(std::vector< spot::acc_cond::rs_pair > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_spot_acc_cond_rs_pair_Sg____nonzero__(std::vector< spot::acc_cond::rs_pair > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_spot_acc_cond_rs_pair_Sg____bool__(std::vector< spot::acc_cond::rs_pair > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< spot::acc_cond::rs_pair >::size_type std_vector_Sl_spot_acc_cond_rs_pair_Sg____len__(std::vector< spot::acc_cond::rs_pair > const *self){
      return self->size();
    }
SWIGINTERN std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *std_vector_Sl_spot_acc_cond_rs_pair_Sg____getslice__(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::difference_type i,std::vector< spot::acc_cond::rs_pair >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_rs_pair_Sg____setslice____SWIG_0(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::difference_type i,std::vector< spot::acc_cond::rs_pair >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >());
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_rs_pair_Sg____setslice____SWIG_1(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::difference_type i,std::vector< spot::acc_cond::rs_pair >::difference_type j,std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_rs_pair_Sg____delslice__(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::difference_type i,std::vector< spot::acc_cond::rs_pair >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_rs_pair_Sg____delitem____SWIG_0(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *std_vector_Sl_spot_acc_cond_rs_pair_Sg____getitem____SWIG_0(std::vector< spot::acc_cond::rs_pair > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >::difference_type id = i;
      std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_rs_pair_Sg____setitem____SWIG_0(std::vector< spot::acc_cond::rs_pair > *self,PySliceObject *slice,std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >::difference_type id = i;
      std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_rs_pair_Sg____setitem____SWIG_1(std::vector< spot::acc_cond::rs_pair > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >::difference_type id = i;
      std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_rs_pair_Sg____delitem____SWIG_1(std::vector< spot::acc_cond::rs_pair > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >::difference_type id = i;
      std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< spot::acc_cond::rs_pair >::value_type const &std_vector_Sl_spot_acc_cond_rs_pair_Sg____getitem____SWIG_1(std::vector< spot::acc_cond::rs_pair > const *self,std::vector< spot::acc_cond::rs_pair >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_rs_pair_Sg____setitem____SWIG_2(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::difference_type i,std::vector< spot::acc_cond::rs_pair >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< spot::acc_cond::rs_pair >::value_type std_vector_Sl_spot_acc_cond_rs_pair_Sg__pop(std::vector< spot::acc_cond::rs_pair > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_spot_acc_cond_rs_pair_Sg__append(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< spot::acc_cond::rs_pair >::iterator std_vector_Sl_spot_acc_cond_rs_pair_Sg__erase__SWIG_0(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< spot::acc_cond::rs_pair >::iterator std_vector_Sl_spot_acc_cond_rs_pair_Sg__erase__SWIG_1(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::iterator first,std::vector< spot::acc_cond::rs_pair >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< spot::acc_cond::rs_pair >::iterator std_vector_Sl_spot_acc_cond_rs_pair_Sg__insert__SWIG_0(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::iterator pos,std::vector< spot::acc_cond::rs_pair >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_spot_acc_cond_rs_pair_Sg__insert__SWIG_1(std::vector< spot::acc_cond::rs_pair > *self,std::vector< spot::acc_cond::rs_pair >::iterator pos,std::vector< spot::acc_cond::rs_pair >::size_type n,std::vector< spot::acc_cond::rs_pair >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN std::string spot_acc_cond___repr__(spot::acc_cond *self){
    std::ostringstream os;
    os << "spot.acc_cond(" << self->num_sets() << ", \""
       << self->get_acceptance() << "\")";
    return os.str();
  }
SWIGINTERN std::string spot_acc_cond___str__(spot::acc_cond *self){
    std::ostringstream os;
    os << *self;
    return os.str();
  }
SWIGINTERN spot::acc_cond::mark_t *new_spot_acc_cond_mark_t__SWIG_1(std::vector< unsigned int,std::allocator< unsigned int > > const &f){
    return new spot::acc_cond::mark_t(f.begin(), f.end());
  }
SWIGINTERN std::string spot_acc_cond_mark_t___repr__(spot::acc_cond::mark_t *self){
    std::ostringstream os;
    os << "spot.mark_t([";
    const char* sep = "";
    for (unsigned s: self->sets())
      {
        os << sep << s;
        sep = ", ";
      }
    os << "])";
    return os.str();
  }
SWIGINTERN std::string spot_acc_cond_mark_t___str__(spot::acc_cond::mark_t *self){
    std::ostringstream os;
    os << *self;
    return os.str();
  }
SWIGINTERN std::string spot_acc_cond_acc_code___repr__(spot::acc_cond::acc_code *self){
    std::ostringstream os;
    os << "spot.acc_code(\"" << *self << "\")";
    return os.str();
  }
SWIGINTERN std::string spot_acc_cond_acc_code___str__(spot::acc_cond::acc_code *self){
    std::ostringstream os;
    os << *self;
    return os.str();
  }
SWIGINTERN std::string spot_acc_cond_rs_pair___repr__(spot::acc_cond::rs_pair *self){
    std::ostringstream os;
    os << "spot.rs_pair(fin=[";
    const char* sep = "";
    for (unsigned s: self->fin.sets())
      {
        os << sep << s;
        sep = ", ";
      }
    os << "], inf=[";
    sep = "";
    for (unsigned s: self->inf.sets())
      {
        os << sep << s;
        sep = ", ";
      }
    os << "])";
    return os.str();
  }
SWIGINTERN swig::SwigPyIterator *spot_internal_mark_container___iter__(spot::internal::mark_container *self,PyObject **PYTHON_SELF){
      return swig::make_forward_iterator_np(self->begin(), self->begin(),
				         self->end(), *PYTHON_SELF);
   }

      namespace swig {
	template <>  struct traits<std::pair< bool, spot::acc_cond::mark_t > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "bool" "," "spot::acc_cond::mark_t" " >";
	  }
	};
      }
    
SWIGINTERN void spot_twa_set_name(spot::twa *self,std::string name){
    self->set_named_prop("automaton-name", new std::string(name));
  }
SWIGINTERN std::string *spot_twa_get_name(spot::twa *self){
    return self->get_named_prop<std::string>("automaton-name");
  }
SWIGINTERN void spot_twa_set_state_names(spot::twa *self,std::vector< std::string,std::allocator< std::string > > names){
    self->set_named_prop("state-names",
			 new std::vector<std::string>(std::move(names)));
  }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > *spot_twa_get_state_names(spot::twa *self){
    return self->get_named_prop<std::vector<std::string>>("state-names");
  }
SWIGINTERN void spot_twa_set_product_states(spot::twa *self,std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > pairs){
    self->set_named_prop("product-states", new
                         std::vector<std::pair<unsigned,
                                               unsigned>>(std::move(pairs)));
  }
SWIGINTERN std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *spot_twa_get_product_states(spot::twa *self){
    return self->get_named_prop
      <std::vector<std::pair<unsigned, unsigned>>>("product-states");
  }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > *spot_twa_get_original_states(spot::twa *self){
    return self->get_named_prop<std::vector<unsigned>>("original-states");
  }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > *spot_twa_get_original_classes(spot::twa *self){
    return self->get_named_prop<std::vector<unsigned>>("original-classes");
  }
SWIGINTERN spot::twa *spot_twa_highlight_state(spot::twa *self,unsigned int state,unsigned int color){
    auto hs =
      self->get_named_prop<std::map<unsigned, unsigned>>("highlight-states");
    if (!hs)
      {
	hs = new std::map<unsigned, unsigned>;
	self->set_named_prop("highlight-states", hs);
      }
    (*hs)[state] = color;
    return self;
  }
SWIGINTERN spot::twa *spot_twa_highlight_edge(spot::twa *self,unsigned int edge,unsigned int color){
    auto ht =
      self->get_named_prop<std::map<unsigned, unsigned>>("highlight-edges");
    if (!ht)
      {
	ht = new std::map<unsigned, unsigned>;
	self->set_named_prop("highlight-edges", ht);
      }
    (*ht)[edge] = color;
    return self;
  }

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


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;
}

SWIGINTERN swig::SwigPyIterator *spot_internal_const_universal_dests___iter__(spot::internal::const_universal_dests *self,PyObject **PYTHON_SELF){
      return swig::make_forward_iterator_np(self->begin(), self->begin(),
				            self->end(), *PYTHON_SELF);
   }

  namespace swig {
    template <>  struct traits< spot::internal::distate_storage<unsigned int,spot::internal::boxed_label<spot::kripke_graph_state,false> > > {
      typedef pointer_category category;
      static const char* type_name() { return"spot::internal::distate_storage<unsigned int,spot::internal::boxed_label<spot::kripke_graph_state,false> >"; }
    };
  }


  namespace swig {
    template <>  struct traits< spot::internal::edge_storage<unsigned int,unsigned int,unsigned int,spot::internal::boxed_label<spot::twa_graph_edge_data,false> > > {
      typedef pointer_category category;
      static const char* type_name() { return"spot::internal::edge_storage<unsigned int,unsigned int,unsigned int,spot::internal::boxed_label<spot::twa_graph_edge_data,false> >"; }
    };
  }


  namespace swig {
    template <>  struct traits< spot::internal::edge_storage<unsigned int,unsigned int,unsigned int,spot::internal::boxed_label<void,true> > > {
      typedef pointer_category category;
      static const char* type_name() { return"spot::internal::edge_storage<unsigned int,unsigned int,unsigned int,spot::internal::boxed_label<void,true> >"; }
    };
  }

SWIGINTERN unsigned int spot_twa_graph_new_univ_edge__SWIG_4(spot::twa_graph *self,unsigned int src,std::vector< unsigned int,std::allocator< unsigned int > > const &v,bdd cond,spot::acc_cond::mark_t acc={}){
    return self->new_univ_edge(src, v.begin(), v.end(), cond, acc);
  }
SWIGINTERN void spot_twa_graph_set_univ_init_state__SWIG_2(spot::twa_graph *self,std::vector< unsigned int,std::allocator< unsigned int > > const &v){
    self->set_univ_init_state(v.begin(), v.end());
  }
SWIGINTERN void spot_twa_graph_report_univ_dest(spot::twa_graph *self,unsigned int src){
    if (self->is_univ_dest(src))
      throw std::runtime_error
        ("universal destinations should be explored with univ_dest()");
  }
SWIGINTERN swig::SwigPyIterator *spot_internal_state_out_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg__Sg____iter__(spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *self,PyObject **PYTHON_SELF){
      return swig::make_forward_iterator(self->begin(), self->begin(),
				         self->end(), *PYTHON_SELF);
   }
SWIGINTERN spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > &spot_internal_killer_edge_iterator_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg__Sg__current(spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *self){
    return **self;
  }
SWIGINTERN void spot_internal_killer_edge_iterator_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg__Sg__advance(spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *self){
    ++*self;
  }
SWIGINTERN bool spot_internal_killer_edge_iterator_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg__Sg____bool__(spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *self){
    return *self;
  }
SWIGINTERN swig::SwigPyIterator *spot_internal_all_trans_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg__Sg____iter__(spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *self,PyObject **PYTHON_SELF){
      return swig::make_forward_iterator(self->begin(), self->begin(),
				         self->end(), *PYTHON_SELF);
   }
SWIGINTERN std::string spot_twa_run___str__(spot::twa_run *self){
    std::ostringstream os;
    os << *self;
    return os.str();
  }

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


      namespace swig {
	template <>  struct traits<std::list< spot::twa_run::step, std::allocator< spot::twa_run::step > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::list<" "spot::twa_run::step" ", " "std::allocator< spot::twa_run::step >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_list_Sl_spot_twa_run_step_Sg__iterator(std::list< spot::twa_run::step > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_list_Sl_spot_twa_run_step_Sg____nonzero__(std::list< spot::twa_run::step > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_list_Sl_spot_twa_run_step_Sg____bool__(std::list< spot::twa_run::step > const *self){
      return !(self->empty());
    }
SWIGINTERN std::list< spot::twa_run::step >::size_type std_list_Sl_spot_twa_run_step_Sg____len__(std::list< spot::twa_run::step > const *self){
      return self->size();
    }
SWIGINTERN std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *std_list_Sl_spot_twa_run_step_Sg____getslice__(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::difference_type i,std::list< spot::twa_run::step >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_list_Sl_spot_twa_run_step_Sg____setslice____SWIG_0(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::difference_type i,std::list< spot::twa_run::step >::difference_type j){
      swig::setslice(self, i, j, 1, std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >());
    }
SWIGINTERN void std_list_Sl_spot_twa_run_step_Sg____setslice____SWIG_1(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::difference_type i,std::list< spot::twa_run::step >::difference_type j,std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_list_Sl_spot_twa_run_step_Sg____delslice__(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::difference_type i,std::list< spot::twa_run::step >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_list_Sl_spot_twa_run_step_Sg____delitem____SWIG_0(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *std_list_Sl_spot_twa_run_step_Sg____getitem____SWIG_0(std::list< spot::twa_run::step > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >::difference_type id = i;
      std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_list_Sl_spot_twa_run_step_Sg____setitem____SWIG_0(std::list< spot::twa_run::step > *self,PySliceObject *slice,std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >::difference_type id = i;
      std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_list_Sl_spot_twa_run_step_Sg____setitem____SWIG_1(std::list< spot::twa_run::step > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >::difference_type id = i;
      std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_list_Sl_spot_twa_run_step_Sg____delitem____SWIG_1(std::list< spot::twa_run::step > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >::difference_type id = i;
      std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::list< spot::twa_run::step >::value_type const &std_list_Sl_spot_twa_run_step_Sg____getitem____SWIG_1(std::list< spot::twa_run::step > const *self,std::list< spot::twa_run::step >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_list_Sl_spot_twa_run_step_Sg____setitem____SWIG_2(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::difference_type i,std::list< spot::twa_run::step >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::list< spot::twa_run::step >::value_type std_list_Sl_spot_twa_run_step_Sg__pop(std::list< spot::twa_run::step > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_list_Sl_spot_twa_run_step_Sg__append(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::list< spot::twa_run::step >::iterator std_list_Sl_spot_twa_run_step_Sg__erase__SWIG_0(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::list< spot::twa_run::step >::iterator std_list_Sl_spot_twa_run_step_Sg__erase__SWIG_1(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::iterator first,std::list< spot::twa_run::step >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::list< spot::twa_run::step >::iterator std_list_Sl_spot_twa_run_step_Sg__insert__SWIG_0(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::iterator pos,std::list< spot::twa_run::step >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_list_Sl_spot_twa_run_step_Sg__insert__SWIG_1(std::list< spot::twa_run::step > *self,std::list< spot::twa_run::step >::iterator pos,std::list< spot::twa_run::step >::size_type n,std::list< spot::twa_run::step >::value_type const &x){ self->insert(pos, n, x); }

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

SWIGINTERN swig::SwigPyIterator *spot_scc_info___iter__(spot::scc_info *self,PyObject **PYTHON_SELF){
      return swig::make_forward_iterator(self->begin(), self->begin(),
                                         self->end(), *PYTHON_SELF);
   }
SWIGINTERN swig::SwigPyIterator *spot_internal_scc_edges_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg_const_Sc_spot_internal_keep_all_Sg____iter__(spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *self,PyObject **PYTHON_SELF){
      return swig::make_forward_iterator(self->begin(), self->begin(),
				         self->end(), *PYTHON_SELF);
   }
SWIGINTERN swig::SwigPyIterator *spot_internal_scc_edges_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg_const_Sc_spot_internal_keep_inner_scc_Sg____iter__(spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *self,PyObject **PYTHON_SELF){
      return swig::make_forward_iterator(self->begin(), self->begin(),
				         self->end(), *PYTHON_SELF);
   }

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


      namespace swig {
	template <>  struct traits<std::vector< std::shared_ptr< spot::twa_graph >, std::allocator< std::shared_ptr< spot::twa_graph > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::shared_ptr< spot::twa_graph >" "," "std::allocator< std::shared_ptr< spot::twa_graph > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_spot_twa_graph_ptr_Sg__iterator(std::vector< spot::twa_graph_ptr > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_spot_twa_graph_ptr_Sg____nonzero__(std::vector< spot::twa_graph_ptr > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_spot_twa_graph_ptr_Sg____bool__(std::vector< spot::twa_graph_ptr > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::shared_ptr< spot::twa_graph > >::size_type std_vector_Sl_spot_twa_graph_ptr_Sg____len__(std::vector< spot::twa_graph_ptr > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *std_vector_Sl_spot_twa_graph_ptr_Sg____getslice__(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type i,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_twa_graph_ptr_Sg____setslice____SWIG_0(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type i,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >());
    }
SWIGINTERN void std_vector_Sl_spot_twa_graph_ptr_Sg____setslice____SWIG_1(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type i,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type j,std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_spot_twa_graph_ptr_Sg____delslice__(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type i,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_twa_graph_ptr_Sg____delitem____SWIG_0(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *std_vector_Sl_spot_twa_graph_ptr_Sg____getitem____SWIG_0(std::vector< spot::twa_graph_ptr > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >::difference_type id = i;
      std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_twa_graph_ptr_Sg____setitem____SWIG_0(std::vector< spot::twa_graph_ptr > *self,PySliceObject *slice,std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >::difference_type id = i;
      std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_spot_twa_graph_ptr_Sg____setitem____SWIG_1(std::vector< spot::twa_graph_ptr > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >::difference_type id = i;
      std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_twa_graph_ptr_Sg____delitem____SWIG_1(std::vector< spot::twa_graph_ptr > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >::difference_type id = i;
      std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &std_vector_Sl_spot_twa_graph_ptr_Sg____getitem____SWIG_1(std::vector< spot::twa_graph_ptr > const *self,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_spot_twa_graph_ptr_Sg____setitem____SWIG_2(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type i,std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::shared_ptr< spot::twa_graph > >::value_type std_vector_Sl_spot_twa_graph_ptr_Sg__pop(std::vector< spot::twa_graph_ptr > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_spot_twa_graph_ptr_Sg__append(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::shared_ptr< spot::twa_graph > >::iterator std_vector_Sl_spot_twa_graph_ptr_Sg__erase__SWIG_0(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::shared_ptr< spot::twa_graph > >::iterator std_vector_Sl_spot_twa_graph_ptr_Sg__erase__SWIG_1(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::iterator first,std::vector< std::shared_ptr< spot::twa_graph > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::shared_ptr< spot::twa_graph > >::iterator std_vector_Sl_spot_twa_graph_ptr_Sg__insert__SWIG_0(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::iterator pos,std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_spot_twa_graph_ptr_Sg__insert__SWIG_1(std::vector< spot::twa_graph_ptr > *self,std::vector< std::shared_ptr< spot::twa_graph > >::iterator pos,std::vector< std::shared_ptr< spot::twa_graph > >::size_type n,std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN std::string spot_twa_word___str__(spot::twa_word *self){
    std::ostringstream os;
    os << *self;
    return os.str();
  }

      namespace swig {
	template <>  struct traits<std::list< bdd, std::allocator< bdd > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::list<" "bdd" ", " "std::allocator< bdd >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_list_Sl_bdd_Sg__iterator(std::list< bdd > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_list_Sl_bdd_Sg____nonzero__(std::list< bdd > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_list_Sl_bdd_Sg____bool__(std::list< bdd > const *self){
      return !(self->empty());
    }
SWIGINTERN std::list< bdd >::size_type std_list_Sl_bdd_Sg____len__(std::list< bdd > const *self){
      return self->size();
    }
SWIGINTERN std::list< bdd,std::allocator< bdd > > *std_list_Sl_bdd_Sg____getslice__(std::list< bdd > *self,std::list< bdd >::difference_type i,std::list< bdd >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_list_Sl_bdd_Sg____setslice____SWIG_0(std::list< bdd > *self,std::list< bdd >::difference_type i,std::list< bdd >::difference_type j){
      swig::setslice(self, i, j, 1, std::list< bdd,std::allocator< bdd > >());
    }
SWIGINTERN void std_list_Sl_bdd_Sg____setslice____SWIG_1(std::list< bdd > *self,std::list< bdd >::difference_type i,std::list< bdd >::difference_type j,std::list< bdd,std::allocator< bdd > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_list_Sl_bdd_Sg____delslice__(std::list< bdd > *self,std::list< bdd >::difference_type i,std::list< bdd >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_list_Sl_bdd_Sg____delitem____SWIG_0(std::list< bdd > *self,std::list< bdd >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::list< bdd,std::allocator< bdd > > *std_list_Sl_bdd_Sg____getitem____SWIG_0(std::list< bdd > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< bdd,std::allocator< bdd > >::difference_type id = i;
      std::list< bdd,std::allocator< bdd > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_list_Sl_bdd_Sg____setitem____SWIG_0(std::list< bdd > *self,PySliceObject *slice,std::list< bdd,std::allocator< bdd > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< bdd,std::allocator< bdd > >::difference_type id = i;
      std::list< bdd,std::allocator< bdd > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_list_Sl_bdd_Sg____setitem____SWIG_1(std::list< bdd > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< bdd,std::allocator< bdd > >::difference_type id = i;
      std::list< bdd,std::allocator< bdd > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_list_Sl_bdd_Sg____delitem____SWIG_1(std::list< bdd > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::list< bdd,std::allocator< bdd > >::difference_type id = i;
      std::list< bdd,std::allocator< bdd > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::list< bdd >::value_type const &std_list_Sl_bdd_Sg____getitem____SWIG_1(std::list< bdd > const *self,std::list< bdd >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_list_Sl_bdd_Sg____setitem____SWIG_2(std::list< bdd > *self,std::list< bdd >::difference_type i,std::list< bdd >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::list< bdd >::value_type std_list_Sl_bdd_Sg__pop(std::list< bdd > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::list< bdd,std::allocator< bdd > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_list_Sl_bdd_Sg__append(std::list< bdd > *self,std::list< bdd >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::list< bdd >::iterator std_list_Sl_bdd_Sg__erase__SWIG_0(std::list< bdd > *self,std::list< bdd >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::list< bdd >::iterator std_list_Sl_bdd_Sg__erase__SWIG_1(std::list< bdd > *self,std::list< bdd >::iterator first,std::list< bdd >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::list< bdd >::iterator std_list_Sl_bdd_Sg__insert__SWIG_0(std::list< bdd > *self,std::list< bdd >::iterator pos,std::list< bdd >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_list_Sl_bdd_Sg__insert__SWIG_1(std::list< bdd > *self,std::list< bdd >::iterator pos,std::list< bdd >::size_type n,std::list< bdd >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN swig::SwigPyIterator *spot_internal_state_out_Sl_spot_digraph_Sl_spot_kripke_graph_state_Sc_void_Sg__Sg____iter__(spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *self,PyObject **PYTHON_SELF){
      return swig::make_forward_iterator(self->begin(), self->begin(),
				         self->end(), *PYTHON_SELF);
   }
SWIGINTERN swig::SwigPyIterator *spot_internal_all_trans_Sl_spot_digraph_Sl_spot_kripke_graph_state_Sc_void_Sg__Sg____iter__(spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *self,PyObject **PYTHON_SELF){
      return swig::make_forward_iterator(self->begin(), self->begin(),
				         self->end(), *PYTHON_SELF);
   }

      namespace swig {
	template <>  struct traits<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >, std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >" "," "std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__iterator(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____nonzero__(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____bool__(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____len__(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____getslice__(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type i,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____setslice____SWIG_0(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type i,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >());
    }
SWIGINTERN void std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____setslice____SWIG_1(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type i,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type j,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____delslice__(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type i,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____delitem____SWIG_0(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____getitem____SWIG_0(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >::difference_type id = i;
      std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____setitem____SWIG_0(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,PySliceObject *slice,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >::difference_type id = i;
      std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____setitem____SWIG_1(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >::difference_type id = i;
      std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____delitem____SWIG_1(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,PySliceObject *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >::difference_type id = i;
      std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____getitem____SWIG_1(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____setitem____SWIG_2(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type i,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__pop(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__append(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__erase__SWIG_0(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__erase__SWIG_1(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator first,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__insert__SWIG_0(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator pos,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__insert__SWIG_1(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *self,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator pos,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type n,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN bool spot_parse_aut_error_list___nonzero__(spot::parse_aut_error_list *self){
  return !self->empty();
}
SWIGINTERN bool spot_parse_aut_error_list___bool__(spot::parse_aut_error_list *self){
  return !self->empty();
}

bool fnode_instances_check()
{
  return spot::fnode::instances_check();
}

spot::twa_graph_ptr
ensure_digraph(const spot::twa_ptr& a)
{
  auto aa = std::dynamic_pointer_cast<spot::twa_graph>(a);
  if (aa)
    return aa;
  return spot::make_twa_graph(a, spot::twa::prop_set::all());
}

std::ostream&
get_cout()
{
  return std::cout;
}

void
nl_cout()
{
  std::cout << std::endl;
}

std::ostream&
get_cerr()
{
  return std::cerr;
}

void
nl_cerr()
{
  std::cerr << std::endl;
}

void
print_on(std::ostream& on, const std::string& what)
{
  on << what;
}

int
unblock_signal(int signum)
{
  sigset_t set;
  sigemptyset(&set);
  sigaddset(&set, signum);
  return sigprocmask(SIG_UNBLOCK, &set, 0);
}

// for alternation.hh
unsigned states_and(const spot::twa_graph_ptr& aut,
                    const std::vector<unsigned>& il)
{
  return states_and(aut, il.begin(), il.end());
}


#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  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);
  delete arg1;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  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(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  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_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &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(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) 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_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (swig::SwigPyIterator *)(arg1)->incr();
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_incr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_SwigPyIterator_incr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator_incr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_incr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::incr(size_t)\n"
    "    swig::SwigPyIterator::incr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  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_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &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(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) 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_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  try {
    result = (swig::SwigPyIterator *)(arg1)->decr();
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator_decr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_SwigPyIterator_decr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator_decr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SwigPyIterator_decr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    swig::SwigPyIterator::decr(size_t)\n"
    "    swig::SwigPyIterator::decr()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  ptrdiff_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_distance", 2, 2, swig_obj)) 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_distance" "', 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_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  try {
    result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
  } catch(std::invalid_argument &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
  }
  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 *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_equal", 2, 2, swig_obj)) 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_equal" "', 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_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  try {
    result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
  } catch(std::invalid_argument &_e) {
    SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
  }
  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 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  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);
  result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  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(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  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(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  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(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator_advance", 2, 2, swig_obj)) 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_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  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_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)(arg1)->advance(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___eq__", 2, 2, swig_obj)) 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___eq__" "', 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___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___ne__", 2, 2, swig_obj)) 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___ne__" "', 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___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___iadd__", 2, 2, swig_obj)) SWIG_fail;
  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 '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  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___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *) &(arg1)->operator +=(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___isub__", 2, 2, swig_obj)) SWIG_fail;
  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 '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  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___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *) &(arg1)->operator -=(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  swig::SwigPyIterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "SwigPyIterator___add__", 2, 2, swig_obj)) 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___add__" "', 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___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  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 = (swig::SwigPyIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  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 -(arg2);
  } catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  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 = (swig::SwigPyIterator *) 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ptrdiff_t result;
  
  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_ValueError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  PyErr_Clear();
  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;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  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_parse_error(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  spot::parse_error *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_parse_error" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_parse_error" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (spot::parse_error *)new spot::parse_error((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__parse_error, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_parse_error(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parse_error *arg1 = (spot::parse_error *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parse_error, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_parse_error" "', argument " "1"" of type '" "spot::parse_error *""'"); 
  }
  arg1 = reinterpret_cast< spot::parse_error * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *parse_error_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__parse_error, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *parse_error_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_parallel_policy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  spot::parallel_policy *result = 0 ;
  
  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 '" "new_parallel_policy" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = (spot::parallel_policy *)new spot::parallel_policy(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__parallel_policy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_parallel_policy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::parallel_policy *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::parallel_policy *)new spot::parallel_policy();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__parallel_policy, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_parallel_policy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_parallel_policy", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_parallel_policy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_parallel_policy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_parallel_policy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::parallel_policy::parallel_policy(unsigned int)\n"
    "    spot::parallel_policy::parallel_policy()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_parallel_policy_nthreads(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parallel_policy *arg1 = (spot::parallel_policy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parallel_policy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parallel_policy_nthreads" "', argument " "1"" of type '" "spot::parallel_policy const *""'"); 
  }
  arg1 = reinterpret_cast< spot::parallel_policy * >(argp1);
  {
    try {
      result = (unsigned int)((spot::parallel_policy const *)arg1)->nthreads();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_parallel_policy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parallel_policy *arg1 = (spot::parallel_policy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parallel_policy, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_parallel_policy" "', argument " "1"" of type '" "spot::parallel_policy *""'"); 
  }
  arg1 = reinterpret_cast< spot::parallel_policy * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *parallel_policy_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__parallel_policy, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *parallel_policy_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_version(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "version", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (char *)spot::version();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_minato_isop__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bdd arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::minato_isop *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_minato_isop" "', argument " "1"" of type '" "bdd""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_minato_isop" "', argument " "1"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = (spot::minato_isop *)new spot::minato_isop(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__minato_isop, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_minato_isop__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bdd arg1 ;
  bdd arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::minato_isop *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_minato_isop" "', argument " "1"" of type '" "bdd""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_minato_isop" "', argument " "1"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_minato_isop" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_minato_isop" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::minato_isop *)new spot::minato_isop(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__minato_isop, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_minato_isop__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bdd arg1 ;
  bdd arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::minato_isop *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_minato_isop" "', argument " "1"" of type '" "bdd""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_minato_isop" "', argument " "1"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_minato_isop" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_minato_isop" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_minato_isop" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (spot::minato_isop *)new spot::minato_isop(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__minato_isop, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_minato_isop(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_minato_isop", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_minato_isop__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_minato_isop__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_minato_isop__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_minato_isop'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::minato_isop::minato_isop(bdd)\n"
    "    spot::minato_isop::minato_isop(bdd,bdd)\n"
    "    spot::minato_isop::minato_isop(bdd,bdd,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_minato_isop_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::minato_isop *arg1 = (spot::minato_isop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bdd result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__minato_isop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minato_isop_next" "', argument " "1"" of type '" "spot::minato_isop *""'"); 
  }
  arg1 = reinterpret_cast< spot::minato_isop * >(argp1);
  {
    try {
      result = (arg1)->next();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_minato_isop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::minato_isop *arg1 = (spot::minato_isop *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__minato_isop, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_minato_isop" "', argument " "1"" of type '" "spot::minato_isop *""'"); 
  }
  arg1 = reinterpret_cast< spot::minato_isop * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *minato_isop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__minato_isop, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *minato_isop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_option_map_parse_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "option_map_parse_options", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_parse_options" "', argument " "1"" of type '" "spot::option_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_parse_options" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->parse_options((char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_option_map_get__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_get" "', argument " "1"" of type '" "spot::option_map const *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_get" "', argument " "2"" of type '" "char const *""'");
  }
  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 '" "option_map_get" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)((spot::option_map const *)arg1)->get((char const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_option_map_get__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_get" "', argument " "1"" of type '" "spot::option_map const *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_get" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (int)((spot::option_map const *)arg1)->get((char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_option_map_get(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "option_map_get", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_option_map_get__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_option_map_get__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'option_map_get'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::option_map::get(char const *,int) const\n"
    "    spot::option_map::get(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_option_map_get_str__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  char *arg2 = (char *) 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_get_str" "', argument " "1"" of type '" "spot::option_map const *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_get_str" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    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 '" "option_map_get_str" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = ((spot::option_map const *)arg1)->get_str((char const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_option_map_get_str__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_get_str" "', argument " "1"" of type '" "spot::option_map const *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_get_str" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = ((spot::option_map const *)arg1)->get_str((char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_option_map_get_str(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "option_map_get_str", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_option_map_get_str__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_option_map_get_str__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'option_map_get_str'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::option_map::get_str(char const *,std::string) const\n"
    "    spot::option_map::get_str(char const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_option_map_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  char *arg2 = (char *) 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 ;
  int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_set" "', argument " "1"" of type '" "spot::option_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_set" "', argument " "2"" of type '" "char const *""'");
  }
  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 '" "option_map_set" "', 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 '" "option_map_set" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (int)(arg1)->set((char const *)arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_option_map_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_set" "', argument " "1"" of type '" "spot::option_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_set" "', argument " "2"" of type '" "char const *""'");
  }
  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 '" "option_map_set" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)(arg1)->set((char const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_option_map_set_if_unset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "option_map_set_if_unset", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_set_if_unset" "', argument " "1"" of type '" "spot::option_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_set_if_unset" "', argument " "2"" of type '" "char const *""'");
  }
  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 '" "option_map_set_if_unset" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      (arg1)->set_if_unset((char const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_option_map_set_str__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  char *arg2 = (char *) 0 ;
  std::string arg3 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  std::string result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_set_str" "', argument " "1"" of type '" "spot::option_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_set_str" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    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 '" "option_map_set_str" "', 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 '" "option_map_set_str" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (arg1)->set_str((char const *)arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_option_map_set_str__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  char *arg2 = (char *) 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_set_str" "', argument " "1"" of type '" "spot::option_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_set_str" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    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 '" "option_map_set_str" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (arg1)->set_str((char const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_option_map_set_str(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "option_map_set_str", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_option_map_set_str__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_option_map_set_str__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'option_map_set_str'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::option_map::set_str(char const *,std::string,std::string)\n"
    "    spot::option_map::set_str(char const *,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_option_map_report_unused_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_report_unused_options" "', argument " "1"" of type '" "spot::option_map const *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  {
    try {
      ((spot::option_map const *)arg1)->report_unused_options();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_option_map_set__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  spot::option_map *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "option_map_set" "', argument " "1"" of type '" "spot::option_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "option_map_set" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "option_map_set" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  {
    try {
      (arg1)->set((spot::option_map const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_option_map_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "option_map_set", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_option_map_set__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_option_map_set__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_option_map_set__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'option_map_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::option_map::set(char const *,int,int)\n"
    "    spot::option_map::set(char const *,int)\n"
    "    spot::option_map::set(spot::option_map const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_option_map(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::option_map *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_option_map", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::option_map *)new spot::option_map();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__option_map, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_option_map(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_option_map" "', argument " "1"" of type '" "spot::option_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *option_map_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__option_map, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *option_map_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_srand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "srand" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      spot::srand(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rrand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "rrand", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rrand" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rrand" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (int)spot::rrand(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mrand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mrand" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (int)spot::mrand(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_drand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "drand", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (double)spot::drand();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nrand(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double result;
  
  if (!SWIG_Python_UnpackTuple(args, "nrand", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (double)spot::nrand();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_escape_rfc4180(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "escape_rfc4180", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "escape_rfc4180" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "escape_rfc4180" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(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 '" "escape_rfc4180" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "escape_rfc4180" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::ostream *) &spot::escape_rfc4180(*arg1,(std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_escape_latex(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "escape_latex", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "escape_latex" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "escape_latex" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(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 '" "escape_latex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "escape_latex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::ostream *) &spot::escape_latex(*arg1,(std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_escape_html(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "escape_html", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "escape_html" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "escape_html" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(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 '" "escape_html" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "escape_html" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::ostream *) &spot::escape_html(*arg1,(std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_escape_str__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "escape_str" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "escape_str" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(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 '" "escape_str" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "escape_str" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::ostream *) &spot::escape_str(*arg1,(std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_escape_str__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "escape_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "escape_str" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = spot::escape_str((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_escape_str(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "escape_str", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_escape_str__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_escape_str__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'escape_str'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::escape_str(std::ostream &,std::string const &)\n"
    "    spot::escape_str(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_quote_shell_string(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "quote_shell_string", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "quote_shell_string" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "quote_shell_string" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "quote_shell_string" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (std::ostream *) &spot::quote_shell_string(*arg1,(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_trival__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::trival *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::trival *)new spot::trival();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__trival, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_trival__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  spot::trival *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_trival" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (spot::trival *)new spot::trival(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__trival, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_trival__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::trival::value_t arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  spot::trival *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_trival" "', argument " "1"" of type '" "spot::trival::value_t""'");
  } 
  arg1 = static_cast< spot::trival::value_t >(val1);
  {
    try {
      result = (spot::trival *)new spot::trival(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__trival, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_trival(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_trival", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_trival__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_bool(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_trival__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_trival__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_trival'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::trival::trival()\n"
    "    spot::trival::trival(bool)\n"
    "    spot::trival::trival(spot::trival::value_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_trival_maybe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival result;
  
  if (!SWIG_Python_UnpackTuple(args, "trival_maybe", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::trival::maybe();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trival_is_known(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival_is_known" "', argument " "1"" of type '" "spot::trival const *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    try {
      result = (bool)((spot::trival const *)arg1)->is_known();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trival_is_maybe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival_is_maybe" "', argument " "1"" of type '" "spot::trival const *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    try {
      result = (bool)((spot::trival const *)arg1)->is_maybe();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trival_is_true(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival_is_true" "', argument " "1"" of type '" "spot::trival const *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    try {
      result = (bool)((spot::trival const *)arg1)->is_true();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trival_is_false(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival_is_false" "', argument " "1"" of type '" "spot::trival const *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    try {
      result = (bool)((spot::trival const *)arg1)->is_false();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trival_val(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::trival::value_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival_val" "', argument " "1"" of type '" "spot::trival const *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    try {
      result = (spot::trival::value_t)((spot::trival const *)arg1)->val();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trival___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival___nonzero__" "', argument " "1"" of type '" "spot::trival const *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    try {
      result = (bool)((spot::trival const *)arg1)->operator bool();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trival___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival___repr__" "', argument " "1"" of type '" "spot::trival *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    try {
      result = spot_trival___repr__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trival___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival___str__" "', argument " "1"" of type '" "spot::trival *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    try {
      result = spot_trival___str__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trival___neg__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::trival result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival___neg__" "', argument " "1"" of type '" "spot::trival *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    try {
      result = spot_trival___neg__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_trival___and__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::trival result;
  
  if (!SWIG_Python_UnpackTuple(args, "trival___and__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival___and__" "', argument " "1"" of type '" "spot::trival *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "trival___and__" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "trival___and__" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot_trival___and__(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_trival___or__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::trival result;
  
  if (!SWIG_Python_UnpackTuple(args, "trival___or__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival___or__" "', argument " "1"" of type '" "spot::trival *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "trival___or__" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "trival___or__" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot_trival___or__(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_trival___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "trival___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival___eq__" "', argument " "1"" of type '" "spot::trival *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "trival___eq__" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "trival___eq__" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)spot_trival___eq__(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_trival___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "trival___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trival___ne__" "', argument " "1"" of type '" "spot::trival *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "trival___ne__" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "trival___ne__" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)spot_trival___ne__(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_trival(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::trival *arg1 = (spot::trival *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__trival, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_trival" "', argument " "1"" of type '" "spot::trival *""'"); 
  }
  arg1 = reinterpret_cast< spot::trival * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *trival_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__trival, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *trival_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___lshift____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::operator <<(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new_formula__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  fnode *arg1 = (fnode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::formula *result = 0 ;
  
  if (SWIG_CheckImplicit(SWIGTYPE_p_spot__formula)) SWIG_fail;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_fnode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_formula" "', argument " "1"" of type '" "fnode const *""'"); 
  }
  arg1 = reinterpret_cast< fnode * >(argp1);
  {
    try {
      result = (spot::formula *)new spot::formula((fnode const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!*result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(*result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_formula__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::nullptr_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::formula *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__nullptr_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_formula" "', argument " "1"" of type '" "std::nullptr_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_formula" "', argument " "1"" of type '" "std::nullptr_t""'");
    } else {
      std::nullptr_t * temp = reinterpret_cast< std::nullptr_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = (spot::formula *)new spot::formula(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!*result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(*result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_formula__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::formula *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::formula *)new spot::formula();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!*result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(*result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_formula__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::formula *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_formula" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_formula" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (spot::formula *)new spot::formula((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!*result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(*result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_formula__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::unique_ptr< spot::formula > rvrdeleter1 ;
  spot::formula *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res1)) {
    if (res1 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_formula" "', cannot release ownership as memory is not owned for argument " "1"" of type '" "spot::formula &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_formula" "', argument " "1"" of type '" "spot::formula &&""'"); 
    }
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_formula" "', argument " "1"" of type '" "spot::formula &&""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  rvrdeleter1.reset(arg1);
  {
    try {
      result = (spot::formula *)new spot::formula((spot::formula &&)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!*result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(*result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_formula(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_formula", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_formula__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__nullptr_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_formula__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_fnode, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_formula__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__formula, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap_new_formula__SWIG_3(self, argc, argv);
  }
check_4:
  
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_spot__formula, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    return _wrap_new_formula__SWIG_4(self, argc, argv);
  }
check_5:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_formula__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_formula'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula::formula(fnode const *)\n"
    "    spot::formula::formula(std::nullptr_t)\n"
    "    spot::formula::formula()\n"
    "    spot::formula::formula(spot::formula const &)\n"
    "    spot::formula::formula(spot::formula &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_formula" "', argument " "1"" of type '" "spot::formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___lt__" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula___lt__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula___lt__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->operator <((spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_formula___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___le__" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula___le__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula___le__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->operator <=((spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_formula___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___gt__" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula___gt__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula___gt__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->operator >((spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_formula___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___ge__" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula___ge__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula___ge__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->operator >=((spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_formula___eq____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___eq__" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula___eq__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula___eq__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->operator ==((spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_formula___eq____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  std::nullptr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___eq__" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__nullptr_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula___eq__" "', argument " "2"" of type '" "std::nullptr_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula___eq__" "', argument " "2"" of type '" "std::nullptr_t""'");
    } else {
      std::nullptr_t * temp = reinterpret_cast< std::nullptr_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::formula const *)arg1)->operator ==(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_formula___eq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula___eq__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__formula, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_formula___eq____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__nullptr_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_formula___eq____SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_formula___eq____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_formula___ne____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___ne__" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula___ne__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula___ne__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->operator !=((spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_formula___ne____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  std::nullptr_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___ne__" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__nullptr_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula___ne__" "', argument " "2"" of type '" "std::nullptr_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula___ne__" "', argument " "2"" of type '" "std::nullptr_t""'");
    } else {
      std::nullptr_t * temp = reinterpret_cast< std::nullptr_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::formula const *)arg1)->operator !=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_formula___ne__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula___ne__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__formula, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_formula___ne____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__nullptr_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_formula___ne____SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_formula___ne____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_formula___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___nonzero__" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->operator bool();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_unbounded(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  uint8_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_unbounded", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (uint8_t)spot::formula::unbounded();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_ap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_ap" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_ap" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = spot::formula::ap((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_ap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_ap" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_ap" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::ap((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_ap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula_ap", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__formula, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_formula_ap__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_formula_ap__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_formula_ap__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'formula_ap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula::ap(std::string const &)\n"
    "    spot::formula::ap(spot::formula const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_formula_unop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::op arg1 ;
  spot::formula *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_unop", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "formula_unop" "', argument " "1"" of type '" "spot::op""'");
  } 
  arg1 = static_cast< spot::op >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_unop" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_unop" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::unop(arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_Not(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Not" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Not" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::Not((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_X__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_X" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_X" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::X((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_X__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  spot::formula *arg2 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::formula result;
  
  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 '" "formula_X" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_X" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_X" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::X(arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_X(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula_X", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_formula_X__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_formula_X__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'formula_X'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula::X(spot::formula const &)\n"
    "    spot::formula::X(unsigned int,spot::formula const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_formula_F__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_F" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_F" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::F((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_F__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  spot::formula *arg3 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::formula result;
  
  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 '" "formula_F" "', 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 '" "formula_F" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "formula_F" "', argument " "3"" of type '" "spot::formula const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_F" "', argument " "3"" of type '" "spot::formula const &""'"); 
  }
  arg3 = reinterpret_cast< spot::formula * >(argp3);
  {
    try {
      result = spot::formula::F(arg1,arg2,(spot::formula const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_F(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula_F", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_formula_F__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_formula_F__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'formula_F'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula::F(spot::formula const &)\n"
    "    spot::formula::F(unsigned int,unsigned int,spot::formula const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_formula_G__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  spot::formula *arg3 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::formula result;
  
  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 '" "formula_G" "', 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 '" "formula_G" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "formula_G" "', argument " "3"" of type '" "spot::formula const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_G" "', argument " "3"" of type '" "spot::formula const &""'"); 
  }
  arg3 = reinterpret_cast< spot::formula * >(argp3);
  {
    try {
      result = spot::formula::G(arg1,arg2,(spot::formula const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_G__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_G" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_G" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::G((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_G(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula_G", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_formula_G__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_formula_G__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'formula_G'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula::G(unsigned int,unsigned int,spot::formula const &)\n"
    "    spot::formula::G(spot::formula const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_formula_Closure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Closure" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Closure" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::Closure((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_NegClosure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_NegClosure" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_NegClosure" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::NegClosure((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_NegClosureMarked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_NegClosureMarked" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_NegClosureMarked" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::NegClosureMarked((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_first_match(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_first_match" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_first_match" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::first_match((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_binop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::op arg1 ;
  spot::formula *arg2 = 0 ;
  spot::formula *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_binop", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "formula_binop" "', argument " "1"" of type '" "spot::op""'");
  } 
  arg1 = static_cast< spot::op >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_binop" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_binop" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "formula_binop" "', argument " "3"" of type '" "spot::formula const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_binop" "', argument " "3"" of type '" "spot::formula const &""'"); 
  }
  arg3 = reinterpret_cast< spot::formula * >(argp3);
  {
    try {
      result = spot::formula::binop(arg1,(spot::formula const &)*arg2,(spot::formula const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_Xor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_Xor", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Xor" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Xor" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_Xor" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Xor" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::Xor((spot::formula const &)*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_Implies(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_Implies", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Implies" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Implies" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_Implies" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Implies" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::Implies((spot::formula const &)*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_Equiv(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_Equiv", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Equiv" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Equiv" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_Equiv" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Equiv" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::Equiv((spot::formula const &)*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_U(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_U", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_U" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_U" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_U" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_U" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::U((spot::formula const &)*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_R(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_R", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_R" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_R" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_R" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_R" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::R((spot::formula const &)*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_W(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_W", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_W" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_W" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_W" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_W" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::W((spot::formula const &)*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_M(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_M", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_M" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_M" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_M" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_M" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::M((spot::formula const &)*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_EConcat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_EConcat", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_EConcat" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_EConcat" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_EConcat" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_EConcat" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::EConcat((spot::formula const &)*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_EConcatMarked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_EConcatMarked", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_EConcatMarked" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_EConcatMarked" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_EConcatMarked" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_EConcatMarked" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::EConcatMarked((spot::formula const &)*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_UConcat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_UConcat", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_UConcat" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_UConcat" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_UConcat" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_UConcat" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::UConcat((spot::formula const &)*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_multop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::op arg1 ;
  std::vector< spot::formula,std::allocator< spot::formula > > *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_multop", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "formula_multop" "', argument " "1"" of type '" "spot::op""'");
  } 
  arg1 = static_cast< spot::op >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_multop" "', argument " "2"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_multop" "', argument " "2"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::formula,std::allocator< spot::formula > > * >(argp2);
  {
    try {
      result = spot::formula::multop(arg1,(std::vector< spot::formula,std::allocator< spot::formula > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_Or(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula,std::allocator< spot::formula > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Or" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Or" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula,std::allocator< spot::formula > > * >(argp1);
  {
    try {
      result = spot::formula::Or((std::vector< spot::formula,std::allocator< spot::formula > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_OrRat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula,std::allocator< spot::formula > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_OrRat" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_OrRat" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula,std::allocator< spot::formula > > * >(argp1);
  {
    try {
      result = spot::formula::OrRat((std::vector< spot::formula,std::allocator< spot::formula > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_And(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula,std::allocator< spot::formula > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_And" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_And" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula,std::allocator< spot::formula > > * >(argp1);
  {
    try {
      result = spot::formula::And((std::vector< spot::formula,std::allocator< spot::formula > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_AndRat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula,std::allocator< spot::formula > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_AndRat" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_AndRat" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula,std::allocator< spot::formula > > * >(argp1);
  {
    try {
      result = spot::formula::AndRat((std::vector< spot::formula,std::allocator< spot::formula > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_AndNLM(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula,std::allocator< spot::formula > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_AndNLM" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_AndNLM" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula,std::allocator< spot::formula > > * >(argp1);
  {
    try {
      result = spot::formula::AndNLM((std::vector< spot::formula,std::allocator< spot::formula > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_Concat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula,std::allocator< spot::formula > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Concat" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Concat" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula,std::allocator< spot::formula > > * >(argp1);
  {
    try {
      result = spot::formula::Concat((std::vector< spot::formula,std::allocator< spot::formula > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_Fusion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula,std::allocator< spot::formula > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Fusion" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Fusion" "', argument " "1"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula,std::allocator< spot::formula > > * >(argp1);
  {
    try {
      result = spot::formula::Fusion((std::vector< spot::formula,std::allocator< spot::formula > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_bunop__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::op arg1 ;
  spot::formula *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  spot::formula result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "formula_bunop" "', argument " "1"" of type '" "spot::op""'");
  } 
  arg1 = static_cast< spot::op >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_bunop" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_bunop" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "formula_bunop" "', 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 '" "formula_bunop" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = spot::formula::bunop(arg1,(spot::formula const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_bunop__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::op arg1 ;
  spot::formula *arg2 = 0 ;
  unsigned int arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  spot::formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "formula_bunop" "', argument " "1"" of type '" "spot::op""'");
  } 
  arg1 = static_cast< spot::op >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_bunop" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_bunop" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "formula_bunop" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = spot::formula::bunop(arg1,(spot::formula const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_bunop__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::op arg1 ;
  spot::formula *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "formula_bunop" "', argument " "1"" of type '" "spot::op""'");
  } 
  arg1 = static_cast< spot::op >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_bunop" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_bunop" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = spot::formula::bunop(arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_bunop(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula_bunop", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_formula_bunop__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_formula_bunop__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_formula_bunop__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'formula_bunop'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula::bunop(spot::op,spot::formula const &,unsigned int,unsigned int)\n"
    "    spot::formula::bunop(spot::op,spot::formula const &,unsigned int)\n"
    "    spot::formula::bunop(spot::op,spot::formula const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_formula_Star__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *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 ;
  spot::formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Star" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Star" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula_Star" "', 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 '" "formula_Star" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = spot::formula::Star((spot::formula const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_Star__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Star" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Star" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula_Star" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = spot::formula::Star((spot::formula const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_Star__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_Star" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_Star" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::Star((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_Star(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula_Star", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_formula_Star__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_formula_Star__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_formula_Star__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'formula_Star'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula::Star(spot::formula const &,unsigned int,unsigned int)\n"
    "    spot::formula::Star(spot::formula const &,unsigned int)\n"
    "    spot::formula::Star(spot::formula const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_formula_FStar__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *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 ;
  spot::formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_FStar" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_FStar" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula_FStar" "', 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 '" "formula_FStar" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = spot::formula::FStar((spot::formula const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_FStar__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_FStar" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_FStar" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula_FStar" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = spot::formula::FStar((spot::formula const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_FStar__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_FStar" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_FStar" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::formula::FStar((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_FStar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula_FStar", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_formula_FStar__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_formula_FStar__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_formula_FStar__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'formula_FStar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula::FStar(spot::formula const &,unsigned int,unsigned int)\n"
    "    spot::formula::FStar(spot::formula const &,unsigned int)\n"
    "    spot::formula::FStar(spot::formula const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_formula_nested_unop_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::op arg1 ;
  spot::op arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  spot::formula arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[5] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_nested_unop_range", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "formula_nested_unop_range" "', argument " "1"" of type '" "spot::op""'");
  } 
  arg1 = static_cast< spot::op >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula_nested_unop_range" "', argument " "2"" of type '" "spot::op""'");
  } 
  arg2 = static_cast< spot::op >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "formula_nested_unop_range" "', 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 '" "formula_nested_unop_range" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[4], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "formula_nested_unop_range" "', argument " "5"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg5 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg5 is fine.
  }
  {
    try {
      result = spot::formula::nested_unop_range(arg1,arg2,arg3,arg4,SWIG_STD_MOVE(arg5));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_sugar_goto(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *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 ;
  PyObject *swig_obj[3] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_sugar_goto", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_sugar_goto" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_sugar_goto" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula_sugar_goto" "', 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 '" "formula_sugar_goto" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = spot::formula::sugar_goto((spot::formula const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_sugar_equal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *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 ;
  PyObject *swig_obj[3] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_sugar_equal", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_sugar_equal" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_sugar_equal" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula_sugar_equal" "', 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 '" "formula_sugar_equal" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = spot::formula::sugar_equal((spot::formula const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_sugar_delay__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  spot::formula result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_sugar_delay" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_sugar_delay" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_sugar_delay" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_sugar_delay" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "formula_sugar_delay" "', 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 '" "formula_sugar_delay" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = spot::formula::sugar_delay((spot::formula const &)*arg1,(spot::formula const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  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_formula_sugar_delay__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *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 ;
  spot::formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_sugar_delay" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_sugar_delay" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula_sugar_delay" "', 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 '" "formula_sugar_delay" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = spot::formula::sugar_delay((spot::formula const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_sugar_delay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula_sugar_delay", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_formula_sugar_delay__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_formula_sugar_delay__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'formula_sugar_delay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula::sugar_delay(spot::formula const &,spot::formula const &,unsigned int,unsigned int)\n"
    "    spot::formula::sugar_delay(spot::formula const &,unsigned int,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_formula_kind(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::op result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_kind" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (spot::op)((spot::formula const *)arg1)->kind();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_kindstr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_kindstr" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = ((spot::formula const *)arg1)->kindstr();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula__is(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  spot::op arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula__is", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula__is" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula__is" "', argument " "2"" of type '" "spot::op""'");
  } 
  arg2 = static_cast< spot::op >(val2);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_get_child_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  spot::op arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_get_child_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_get_child_of" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula_get_child_of" "', argument " "2"" of type '" "spot::op""'");
  } 
  arg2 = static_cast< spot::op >(val2);
  {
    try {
      result = ((spot::formula const *)arg1)->get_child_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_min" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (unsigned int)((spot::formula const *)arg1)->min();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_max" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (unsigned int)((spot::formula const *)arg1)->max();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_size" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (unsigned int)((spot::formula const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_leaf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_leaf" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_leaf();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_id(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_id" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = ((spot::formula const *)arg1)->id();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_ff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_ff", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::formula::ff();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_ff(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_ff" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_ff();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_tt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_tt", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::formula::tt();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_tt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_tt" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_tt();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_eword(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_eword", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::formula::eword();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_eword(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_eword" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_eword();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_constant(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_constant" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_constant();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_Kleene_star(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_Kleene_star" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_Kleene_star();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_one_star(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_one_star", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::formula::one_star();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_one_plus(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_one_plus", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::formula::one_plus();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_literal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_literal" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_literal();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_ap_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_ap_name" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (std::string *) &((spot::formula const *)arg1)->ap_name();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_dump(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_dump", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_dump" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_dump" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "formula_dump" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::formula const *)arg1)->dump(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_all_but(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula_all_but", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_all_but" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula_all_but" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::formula const *)arg1)->all_but(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_boolean_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_boolean_count" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (unsigned int)((spot::formula const *)arg1)->boolean_count();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_boolean_operands__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  unsigned int *arg2 = (unsigned int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_boolean_operands" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_boolean_operands" "', argument " "2"" of type '" "unsigned int *""'"); 
  }
  arg2 = reinterpret_cast< unsigned int * >(argp2);
  {
    try {
      result = ((spot::formula const *)arg1)->boolean_operands(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_boolean_operands__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_boolean_operands" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = ((spot::formula const *)arg1)->boolean_operands();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_boolean_operands(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula_boolean_operands", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_formula_boolean_operands__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_formula_boolean_operands__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'formula_boolean_operands'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula::boolean_operands(unsigned int *) const\n"
    "    spot::formula::boolean_operands() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_formula_is_boolean(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_boolean" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_boolean();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_sugar_free_boolean(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_sugar_free_boolean" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_sugar_free_boolean();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_in_nenoform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_in_nenoform" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_in_nenoform();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_syntactic_stutter_invariant(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_syntactic_stutter_invariant" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_syntactic_stutter_invariant();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_sugar_free_ltl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_sugar_free_ltl" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_sugar_free_ltl();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_ltl_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_ltl_formula" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_ltl_formula();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_psl_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_psl_formula" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_psl_formula();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_sere_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_sere_formula" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_sere_formula();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_finite(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_finite" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_finite();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_eventual(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_eventual" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_eventual();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_universal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_universal" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_universal();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_syntactic_safety(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_syntactic_safety" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_syntactic_safety();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_syntactic_guarantee(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_syntactic_guarantee" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_syntactic_guarantee();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_syntactic_obligation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_syntactic_obligation" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_syntactic_obligation();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_syntactic_recurrence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_syntactic_recurrence" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_syntactic_recurrence();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_syntactic_persistence(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_syntactic_persistence" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_syntactic_persistence();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_is_marked(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_is_marked" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->is_marked();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_accepts_eword(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_accepts_eword" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->accepts_eword();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_has_lbt_atomic_props(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_has_lbt_atomic_props" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->has_lbt_atomic_props();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_has_spin_atomic_props(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula_has_spin_atomic_props" "', argument " "1"" of type '" "spot::formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (bool)((spot::formula const *)arg1)->has_spin_atomic_props();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula___cmp__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula___cmp__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___cmp__" "', argument " "1"" of type '" "spot::formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "formula___cmp__" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (int)spot_formula___cmp__(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula___hash__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___hash__" "', argument " "1"" of type '" "spot::formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot_formula___hash__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___len__" "', argument " "1"" of type '" "spot::formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = (unsigned int)spot_formula___len__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "formula___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___getitem__" "', argument " "1"" of type '" "spot::formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "formula___getitem__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = spot_formula___getitem__(arg1,arg2);
    }
    catch (const std::runtime_error& e)
    {
      SWIG_exception(SWIG_IndexError, e.what());
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___repr__" "', argument " "1"" of type '" "spot::formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot_formula___repr__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "formula___str__" "', argument " "1"" of type '" "spot::formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot_formula___str__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *formula_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__formula, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *formula_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_print_formula_props__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_formula_props" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_formula_props" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_formula_props" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_formula_props" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "print_formula_props" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (std::ostream *) &spot::print_formula_props(*arg1,(spot::formula const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_formula_props__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_formula_props" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_formula_props" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_formula_props" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_formula_props" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = (std::ostream *) &spot::print_formula_props(*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_formula_props(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_formula_props", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_formula_props__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_formula_props__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_formula_props'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_formula_props(std::ostream &,spot::formula const &,bool)\n"
    "    spot::print_formula_props(std::ostream &,spot::formula const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_formula_props(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_formula_props" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_formula_props" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    try {
      result = spot::list_formula_props((spot::formula const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::list< std::string,std::allocator< std::string > >(result)), SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap___lshift____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "spot::formula const &""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = (std::ostream *) &spot::operator <<(*arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_liststr_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_iterator" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_list_Sl_std_string_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___nonzero__" "', argument " "1"" of type '" "std::list< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = (bool)std_list_Sl_std_string_Sg____nonzero__((std::list< std::string > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___bool__" "', argument " "1"" of type '" "std::list< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = (bool)std_list_Sl_std_string_Sg____bool__((std::list< std::string > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___len__" "', argument " "1"" of type '" "std::list< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = std_list_Sl_std_string_Sg____len__((std::list< std::string > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::difference_type arg2 ;
  std::list< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::list< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "liststr___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___getslice__" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "liststr___getslice__" "', argument " "2"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::list< 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 '" "liststr___getslice__" "', argument " "3"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::list< std::string >::difference_type >(val3);
  {
    try {
      try {
        result = (std::list< std::string,std::allocator< std::string > > *)std_list_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::difference_type arg2 ;
  std::list< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___setslice__" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "liststr___setslice__" "', argument " "2"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::list< 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 '" "liststr___setslice__" "', argument " "3"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::list< std::string >::difference_type >(val3);
  {
    try {
      try {
        std_list_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::difference_type arg2 ;
  std::list< std::string >::difference_type arg3 ;
  std::list< 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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___setslice__" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "liststr___setslice__" "', argument " "2"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::list< 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 '" "liststr___setslice__" "', argument " "3"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::list< std::string >::difference_type >(val3);
  {
    std::list< std::string,std::allocator< std::string > > *ptr = (std::list< 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 '" "liststr___setslice__" "', argument " "4"" of type '" "std::list< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr___setslice__" "', argument " "4"" of type '" "std::list< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_list_Sl_std_string_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::list< 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "liststr___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_liststr___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_liststr___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'liststr___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< std::string >::__setslice__(std::list< std::string >::difference_type,std::list< std::string >::difference_type)\n"
    "    std::list< std::string >::__setslice__(std::list< std::string >::difference_type,std::list< std::string >::difference_type,std::list< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_liststr___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::difference_type arg2 ;
  std::list< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "liststr___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___delslice__" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "liststr___delslice__" "', argument " "2"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::list< 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 '" "liststr___delslice__" "', argument " "3"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::list< std::string >::difference_type >(val3);
  {
    try {
      try {
        std_list_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___delitem__" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "liststr___delitem__" "', argument " "2"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::list< std::string >::difference_type >(val2);
  {
    try {
      try {
        std_list_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::list< std::string,std::allocator< std::string > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___getitem__" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "liststr___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::list< std::string,std::allocator< std::string > > *)std_list_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::list< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___setitem__" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "liststr___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::list< std::string,std::allocator< std::string > > *ptr = (std::list< 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 '" "liststr___setitem__" "', argument " "3"" of type '" "std::list< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr___setitem__" "', argument " "3"" of type '" "std::list< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_list_Sl_std_string_Sg____setitem____SWIG_0(arg1,arg2,(std::list< 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___setitem__" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "liststr___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_list_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___delitem__" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "liststr___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_list_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "liststr___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_liststr___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_liststr___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'liststr___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< std::string >::__delitem__(std::list< std::string >::difference_type)\n"
    "    std::list< std::string >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_liststr___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::list< std::string >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___getitem__" "', argument " "1"" of type '" "std::list< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "liststr___getitem__" "', argument " "2"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::list< std::string >::difference_type >(val2);
  {
    try {
      try {
        result = (std::list< std::string >::value_type *) &std_list_Sl_std_string_Sg____getitem____SWIG_1((std::list< std::string > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::list< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "liststr___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_liststr___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_liststr___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'liststr___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< std::string >::__getitem__(PySliceObject *)\n"
    "    std::list< std::string >::__getitem__(std::list< std::string >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_liststr___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::difference_type arg2 ;
  std::list< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr___setitem__" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "liststr___setitem__" "', argument " "2"" of type '" "std::list< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::list< 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 '" "liststr___setitem__" "', argument " "3"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr___setitem__" "', argument " "3"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_list_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "liststr___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_liststr___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::list< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_liststr___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_liststr___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'liststr___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< std::string >::__setitem__(PySliceObject *,std::list< std::string,std::allocator< std::string > > const &)\n"
    "    std::list< std::string >::__setitem__(PySliceObject *)\n"
    "    std::list< std::string >::__setitem__(std::list< std::string >::difference_type,std::list< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_liststr_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< std::string >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_pop" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      try {
        result = std_list_Sl_std_string_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "liststr_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_append" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(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 '" "liststr_append" "', argument " "2"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr_append" "', argument " "2"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_list_Sl_std_string_Sg__append(arg1,(std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_liststr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::list< std::string > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::list< std::string > *)new std::list< std::string >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_liststr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::list< std::string > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::list< std::string,std::allocator< std::string > > *ptr = (std::list< 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_liststr" "', argument " "1"" of type '" "std::list< std::string > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_liststr" "', argument " "1"" of type '" "std::list< std::string > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::list< std::string > *)new std::list< std::string >((std::list< std::string > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_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_liststr_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_empty" "', argument " "1"" of type '" "std::list< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = (bool)((std::list< std::string > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_size" "', argument " "1"" of type '" "std::list< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = ((std::list< std::string > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "liststr_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_swap" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "liststr_swap" "', argument " "2"" of type '" "std::list< std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr_swap" "', argument " "2"" of type '" "std::list< std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::list< std::string > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< std::string >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_begin" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< std::string >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_end" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< std::string >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_rbegin" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< std::string >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_rend" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_clear" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_get_allocator" "', argument " "1"" of type '" "std::list< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = ((std::list< std::string > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::list< 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_liststr__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::list< std::string > *result = 0 ;
  
  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_liststr" "', argument " "1"" of type '" "std::list< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::list< std::string >::size_type >(val1);
  {
    try {
      result = (std::list< std::string > *)new std::list< std::string >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_pop_back" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_resize" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "liststr_resize" "', argument " "2"" of type '" "std::list< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::list< std::string >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::list< std::string >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_erase" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< 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 '" "liststr_erase" "', argument " "2"" of type '" "std::list< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "liststr_erase" "', argument " "2"" of type '" "std::list< std::string >::iterator""'");
    }
  }
  {
    try {
      result = std_list_Sl_std_string_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::iterator arg2 ;
  std::list< std::string >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::list< std::string >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_erase" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< 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 '" "liststr_erase" "', argument " "2"" of type '" "std::list< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "liststr_erase" "', argument " "2"" of type '" "std::list< 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 '" "liststr_erase" "', argument " "3"" of type '" "std::list< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< std::string >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "liststr_erase" "', argument " "3"" of type '" "std::list< std::string >::iterator""'");
    }
  }
  {
    try {
      result = std_list_Sl_std_string_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "liststr_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_liststr_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_liststr_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'liststr_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< std::string >::erase(std::list< std::string >::iterator)\n"
    "    std::list< std::string >::erase(std::list< std::string >::iterator,std::list< std::string >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_liststr__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string >::size_type arg1 ;
  std::list< std::string >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::list< std::string > *result = 0 ;
  
  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_liststr" "', argument " "1"" of type '" "std::list< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::list< 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_liststr" "', argument " "2"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_liststr" "', argument " "2"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::list< std::string > *)new std::list< std::string >(arg1,(std::list< std::string >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_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_liststr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_liststr", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_liststr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_liststr__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_liststr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_liststr__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_liststr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< std::string >::list()\n"
    "    std::list< std::string >::list(std::list< std::string > const &)\n"
    "    std::list< std::string >::list(std::list< std::string >::size_type)\n"
    "    std::list< std::string >::list(std::list< std::string >::size_type,std::list< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_liststr_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "liststr_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_push_back" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(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 '" "liststr_push_back" "', argument " "2"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr_push_back" "', argument " "2"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::list< std::string >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< std::string >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_front" "', argument " "1"" of type '" "std::list< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = (std::list< std::string >::value_type *) &((std::list< std::string > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::list< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< std::string >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_back" "', argument " "1"" of type '" "std::list< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      result = (std::list< std::string >::value_type *) &((std::list< std::string > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::list< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::size_type arg2 ;
  std::list< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "liststr_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_assign" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "liststr_assign" "', argument " "2"" of type '" "std::list< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::list< 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 '" "liststr_assign" "', argument " "3"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr_assign" "', argument " "3"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::list< std::string >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::size_type arg2 ;
  std::list< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_resize" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "liststr_resize" "', argument " "2"" of type '" "std::list< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::list< 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 '" "liststr_resize" "', argument " "3"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr_resize" "', argument " "3"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::list< std::string >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "liststr_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_liststr_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_liststr_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'liststr_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< std::string >::resize(std::list< std::string >::size_type)\n"
    "    std::list< std::string >::resize(std::list< std::string >::size_type,std::list< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_liststr_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::iterator arg2 ;
  std::list< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::list< std::string >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_insert" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< 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 '" "liststr_insert" "', argument " "2"" of type '" "std::list< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "liststr_insert" "', argument " "2"" of type '" "std::list< 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 '" "liststr_insert" "', argument " "3"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr_insert" "', argument " "3"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_list_Sl_std_string_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< 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_liststr_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::iterator arg2 ;
  std::list< std::string >::size_type arg3 ;
  std::list< 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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_insert" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< 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 '" "liststr_insert" "', argument " "2"" of type '" "std::list< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "liststr_insert" "', argument " "2"" of type '" "std::list< std::string >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "liststr_insert" "', argument " "3"" of type '" "std::list< std::string >::size_type""'");
  } 
  arg3 = static_cast< std::list< 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 '" "liststr_insert" "', argument " "4"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr_insert" "', argument " "4"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_list_Sl_std_string_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::string const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "liststr_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_liststr_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_liststr_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'liststr_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< std::string >::insert(std::list< std::string >::iterator,std::list< std::string >::value_type const &)\n"
    "    std::list< std::string >::insert(std::list< std::string >::iterator,std::list< std::string >::size_type,std::list< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_liststr_pop_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_pop_front" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      (arg1)->pop_front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_push_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  std::list< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "liststr_push_front", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_push_front" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(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 '" "liststr_push_front" "', argument " "2"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "liststr_push_front" "', argument " "2"" of type '" "std::list< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_front((std::list< std::string >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_liststr_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "liststr_reverse" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      (arg1)->reverse();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_liststr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< std::string > *arg1 = (std::list< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_liststr" "', argument " "1"" of type '" "std::list< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< std::string > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *liststr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__listT_std__string_std__allocatorT_std__string_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *liststr_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairunsigned__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< unsigned int,unsigned int > *)new std::pair< unsigned int,unsigned int >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pairunsigned__SWIG_1(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::pair< unsigned int,unsigned int > *result = 0 ;
  
  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 '" "new_pairunsigned" "', 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 '" "new_pairunsigned" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (std::pair< unsigned int,unsigned int > *)new std::pair< unsigned int,unsigned int >(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pairunsigned__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< unsigned int,unsigned int > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairunsigned" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairunsigned" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< unsigned int,unsigned int > *)new std::pair< unsigned int,unsigned int >((std::pair< unsigned int,unsigned int > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_unsigned_int_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_new_pairunsigned(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairunsigned", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_pairunsigned__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairunsigned__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairunsigned__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairunsigned'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< unsigned int,unsigned int >::pair()\n"
    "    std::pair< unsigned int,unsigned int >::pair(unsigned int,unsigned int)\n"
    "    std::pair< unsigned int,unsigned int >::pair(std::pair< unsigned int,unsigned int > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_pairunsigned_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pairunsigned_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairunsigned_first_set" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< unsigned int,unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairunsigned_first_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->first = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairunsigned_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairunsigned_first_get" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< unsigned int,unsigned int > * >(argp1);
  result = (unsigned int) ((arg1)->first);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairunsigned_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pairunsigned_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairunsigned_second_set" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< unsigned int,unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairunsigned_second_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->second = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairunsigned_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairunsigned_second_get" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< unsigned int,unsigned int > * >(argp1);
  result = (unsigned int) ((arg1)->second);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_pairunsigned(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< unsigned int,unsigned int > *arg1 = (std::pair< unsigned int,unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairunsigned" "', argument " "1"" of type '" "std::pair< unsigned int,unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< unsigned int,unsigned int > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *pairunsigned_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairunsigned_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairmark_t__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *)new std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pairmark_t__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairmark_t" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairmark_t" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_pairmark_t" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairmark_t" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *)new std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t >(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pairmark_t__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *ptr = (std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairmark_t" "', argument " "1"" of type '" "std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairmark_t" "', argument " "1"" of type '" "std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *)new std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t >((std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_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_new_pairmark_t(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairmark_t", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_pairmark_t__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairmark_t__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairmark_t__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairmark_t'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t >::pair()\n"
    "    std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t >::pair(spot::acc_cond::mark_t,spot::acc_cond::mark_t)\n"
    "    std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t >::pair(std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_pairmark_t_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *arg1 = (std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *) 0 ;
  spot::acc_cond::mark_t *arg2 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pairmark_t_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairmark_t_first_set" "', argument " "1"" of type '" "std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairmark_t_first_set" "', argument " "2"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
  if (arg1) (arg1)->first = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairmark_t_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *arg1 = (std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairmark_t_first_get" "', argument " "1"" of type '" "std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > * >(argp1);
  result = (spot::acc_cond::mark_t *)& ((arg1)->first);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairmark_t_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *arg1 = (std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *) 0 ;
  spot::acc_cond::mark_t *arg2 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pairmark_t_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairmark_t_second_set" "', argument " "1"" of type '" "std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairmark_t_second_set" "', argument " "2"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
  if (arg1) (arg1)->second = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairmark_t_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *arg1 = (std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairmark_t_second_get" "', argument " "1"" of type '" "std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > * >(argp1);
  result = (spot::acc_cond::mark_t *)& ((arg1)->second);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_pairmark_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *arg1 = (std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairmark_t" "', argument " "1"" of type '" "std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *pairmark_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairmark_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairintacccode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond::acc_code > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< int,spot::acc_cond::acc_code > *)new std::pair< int,spot::acc_cond::acc_code >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_spot__acc_cond__acc_code_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pairintacccode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  spot::acc_cond::acc_code arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::pair< int,spot::acc_cond::acc_code > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_pairintacccode" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_pairintacccode" "', argument " "2"" of type '" "spot::acc_cond::acc_code""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairintacccode" "', argument " "2"" of type '" "spot::acc_cond::acc_code""'");
    } else {
      spot::acc_cond::acc_code * temp = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (std::pair< int,spot::acc_cond::acc_code > *)new std::pair< int,spot::acc_cond::acc_code >(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_spot__acc_cond__acc_code_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pairintacccode__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond::acc_code > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< int,spot::acc_cond::acc_code > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< int,spot::acc_cond::acc_code > *ptr = (std::pair< int,spot::acc_cond::acc_code > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairintacccode" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond::acc_code > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairintacccode" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond::acc_code > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< int,spot::acc_cond::acc_code > *)new std::pair< int,spot::acc_cond::acc_code >((std::pair< int,spot::acc_cond::acc_code > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_spot__acc_cond__acc_code_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_pairintacccode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairintacccode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_pairintacccode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairintacccode__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairintacccode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairintacccode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< int,spot::acc_cond::acc_code >::pair()\n"
    "    std::pair< int,spot::acc_cond::acc_code >::pair(int,spot::acc_cond::acc_code)\n"
    "    std::pair< int,spot::acc_cond::acc_code >::pair(std::pair< int,spot::acc_cond::acc_code > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_pairintacccode_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond::acc_code > *arg1 = (std::pair< int,spot::acc_cond::acc_code > *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pairintacccode_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_int_spot__acc_cond__acc_code_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairintacccode_first_set" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairintacccode_first_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->first = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairintacccode_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond::acc_code > *arg1 = (std::pair< int,spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_int_spot__acc_cond__acc_code_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairintacccode_first_get" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,spot::acc_cond::acc_code > * >(argp1);
  result = (int) ((arg1)->first);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairintacccode_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond::acc_code > *arg1 = (std::pair< int,spot::acc_cond::acc_code > *) 0 ;
  spot::acc_cond::acc_code *arg2 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pairintacccode_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_int_spot__acc_cond__acc_code_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairintacccode_second_set" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,spot::acc_cond::acc_code > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairintacccode_second_set" "', argument " "2"" of type '" "spot::acc_cond::acc_code *""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  if (arg1) (arg1)->second = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairintacccode_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond::acc_code > *arg1 = (std::pair< int,spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_int_spot__acc_cond__acc_code_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairintacccode_second_get" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,spot::acc_cond::acc_code > * >(argp1);
  result = (spot::acc_cond::acc_code *)& ((arg1)->second);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_pairintacccode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond::acc_code > *arg1 = (std::pair< int,spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_int_spot__acc_cond__acc_code_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairintacccode" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *pairintacccode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_int_spot__acc_cond__acc_code_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairintacccode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pairintacccond__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< int,spot::acc_cond > *)new std::pair< int,spot::acc_cond >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_spot__acc_cond_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pairintacccond__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  spot::acc_cond arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::pair< int,spot::acc_cond > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_pairintacccond" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_pairintacccond" "', argument " "2"" of type '" "spot::acc_cond""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairintacccond" "', argument " "2"" of type '" "spot::acc_cond""'");
    } else {
      spot::acc_cond * temp = reinterpret_cast< spot::acc_cond * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (std::pair< int,spot::acc_cond > *)new std::pair< int,spot::acc_cond >(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_spot__acc_cond_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pairintacccond__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< int,spot::acc_cond > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< int,spot::acc_cond > *ptr = (std::pair< int,spot::acc_cond > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pairintacccond" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pairintacccond" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< int,spot::acc_cond > *)new std::pair< int,spot::acc_cond >((std::pair< int,spot::acc_cond > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_int_spot__acc_cond_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_pairintacccond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pairintacccond", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_pairintacccond__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_pairintacccond__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_pairintacccond__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pairintacccond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< int,spot::acc_cond >::pair()\n"
    "    std::pair< int,spot::acc_cond >::pair(int,spot::acc_cond)\n"
    "    std::pair< int,spot::acc_cond >::pair(std::pair< int,spot::acc_cond > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_pairintacccond_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond > *arg1 = (std::pair< int,spot::acc_cond > *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pairintacccond_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_int_spot__acc_cond_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairintacccond_first_set" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pairintacccond_first_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->first = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairintacccond_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond > *arg1 = (std::pair< int,spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_int_spot__acc_cond_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairintacccond_first_get" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,spot::acc_cond > * >(argp1);
  result = (int) ((arg1)->first);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairintacccond_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond > *arg1 = (std::pair< int,spot::acc_cond > *) 0 ;
  spot::acc_cond *arg2 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pairintacccond_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_int_spot__acc_cond_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairintacccond_second_set" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,spot::acc_cond > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pairintacccond_second_set" "', argument " "2"" of type '" "spot::acc_cond *""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond * >(argp2);
  if (arg1) (arg1)->second = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pairintacccond_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond > *arg1 = (std::pair< int,spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_int_spot__acc_cond_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pairintacccond_second_get" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,spot::acc_cond > * >(argp1);
  result = (spot::acc_cond *)& ((arg1)->second);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_pairintacccond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< int,spot::acc_cond > *arg1 = (std::pair< int,spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_int_spot__acc_cond_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pairintacccond" "', argument " "1"" of type '" "std::pair< int,spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< int,spot::acc_cond > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *pairintacccond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_int_spot__acc_cond_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pairintacccond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_vectorformula_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_iterator" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_spot_formula_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___nonzero__" "', argument " "1"" of type '" "std::vector< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_formula_Sg____nonzero__((std::vector< spot::formula > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___bool__" "', argument " "1"" of type '" "std::vector< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_formula_Sg____bool__((std::vector< spot::formula > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___len__" "', argument " "1"" of type '" "std::vector< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = std_vector_Sl_spot_formula_Sg____len__((std::vector< spot::formula > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::difference_type arg2 ;
  std::vector< spot::formula >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< spot::formula,std::allocator< spot::formula > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorformula___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___getslice__" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula___getslice__" "', argument " "2"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorformula___getslice__" "', argument " "3"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::formula >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< spot::formula,std::allocator< spot::formula > > *)std_vector_Sl_spot_formula_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::difference_type arg2 ;
  std::vector< spot::formula >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___setslice__" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula___setslice__" "', argument " "2"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorformula___setslice__" "', argument " "3"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::formula >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_formula_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::difference_type arg2 ;
  std::vector< spot::formula >::difference_type arg3 ;
  std::vector< spot::formula,std::allocator< spot::formula > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___setslice__" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula___setslice__" "', argument " "2"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorformula___setslice__" "', argument " "3"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::formula >::difference_type >(val3);
  {
    std::vector< spot::formula,std::allocator< spot::formula > > *ptr = (std::vector< spot::formula,std::allocator< spot::formula > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectorformula___setslice__" "', argument " "4"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorformula___setslice__" "', argument " "4"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_formula_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< spot::formula,std::allocator< spot::formula > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorformula___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorformula___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorformula___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorformula___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::formula >::__setslice__(std::vector< spot::formula >::difference_type,std::vector< spot::formula >::difference_type)\n"
    "    std::vector< spot::formula >::__setslice__(std::vector< spot::formula >::difference_type,std::vector< spot::formula >::difference_type,std::vector< spot::formula,std::allocator< spot::formula > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorformula___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::difference_type arg2 ;
  std::vector< spot::formula >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorformula___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___delslice__" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula___delslice__" "', argument " "2"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorformula___delslice__" "', argument " "3"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::formula >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_formula_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___delitem__" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula___delitem__" "', argument " "2"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_spot_formula_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< spot::formula,std::allocator< spot::formula > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___getitem__" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorformula___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< spot::formula,std::allocator< spot::formula > > *)std_vector_Sl_spot_formula_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< spot::formula,std::allocator< spot::formula > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___setitem__" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorformula___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< spot::formula,std::allocator< spot::formula > > *ptr = (std::vector< spot::formula,std::allocator< spot::formula > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorformula___setitem__" "', argument " "3"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorformula___setitem__" "', argument " "3"" of type '" "std::vector< spot::formula,std::allocator< spot::formula > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_formula_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< spot::formula,std::allocator< spot::formula > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___setitem__" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorformula___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_formula_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___delitem__" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorformula___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_formula_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorformula___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorformula___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorformula___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorformula___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::formula >::__delitem__(std::vector< spot::formula >::difference_type)\n"
    "    std::vector< spot::formula >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorformula___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< spot::formula >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___getitem__" "', argument " "1"" of type '" "std::vector< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula___getitem__" "', argument " "2"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< spot::formula >::value_type *) &std_vector_Sl_spot_formula_Sg____getitem____SWIG_1((std::vector< spot::formula > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__formula, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::formula >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorformula___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorformula___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorformula___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorformula___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::formula >::__getitem__(PySliceObject *)\n"
    "    std::vector< spot::formula >::__getitem__(std::vector< spot::formula >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorformula___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::difference_type arg2 ;
  std::vector< spot::formula >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula___setitem__" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula___setitem__" "', argument " "2"" of type '" "std::vector< spot::formula >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorformula___setitem__" "', argument " "3"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorformula___setitem__" "', argument " "3"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::formula >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_spot_formula_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(spot::formula const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorformula___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorformula___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< spot::formula,std::allocator< spot::formula > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vectorformula___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorformula___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorformula___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorformula___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::formula >::__setitem__(PySliceObject *,std::vector< spot::formula,std::allocator< spot::formula > > const &)\n"
    "    std::vector< spot::formula >::__setitem__(PySliceObject *)\n"
    "    std::vector< spot::formula >::__setitem__(std::vector< spot::formula >::difference_type,std::vector< spot::formula >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorformula_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_pop" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_spot_formula_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorformula_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_append" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorformula_append" "', argument " "2"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorformula_append" "', argument " "2"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::formula >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_spot_formula_Sg__append(arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorformula__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< spot::formula > *)new std::vector< spot::formula >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorformula__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< spot::formula > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< spot::formula,std::allocator< spot::formula > > *ptr = (std::vector< spot::formula,std::allocator< spot::formula > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vectorformula" "', argument " "1"" of type '" "std::vector< spot::formula > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorformula" "', argument " "1"" of type '" "std::vector< spot::formula > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< spot::formula > *)new std::vector< spot::formula >((std::vector< spot::formula > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_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_vectorformula_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_empty" "', argument " "1"" of type '" "std::vector< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = (bool)((std::vector< spot::formula > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_size" "', argument " "1"" of type '" "std::vector< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = ((std::vector< spot::formula > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorformula_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_swap" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorformula_swap" "', argument " "2"" of type '" "std::vector< spot::formula > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorformula_swap" "', argument " "2"" of type '" "std::vector< spot::formula > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::formula > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_begin" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_end" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_rbegin" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::formula >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_rend" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::formula >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_clear" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< spot::formula > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_get_allocator" "', argument " "1"" of type '" "std::vector< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = ((std::vector< spot::formula > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::formula >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_spot__formula_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorformula__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< spot::formula > *result = 0 ;
  
  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_vectorformula" "', argument " "1"" of type '" "std::vector< spot::formula >::size_type""'");
  } 
  arg1 = static_cast< std::vector< spot::formula >::size_type >(val1);
  {
    try {
      result = (std::vector< spot::formula > *)new std::vector< spot::formula >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_pop_back" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_resize" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula_resize" "', argument " "2"" of type '" "std::vector< spot::formula >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< spot::formula >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_erase" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(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 '" "vectorformula_erase" "', argument " "2"" of type '" "std::vector< spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::formula >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorformula_erase" "', argument " "2"" of type '" "std::vector< spot::formula >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_formula_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::iterator arg2 ;
  std::vector< spot::formula >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< spot::formula >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_erase" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(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 '" "vectorformula_erase" "', argument " "2"" of type '" "std::vector< spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::formula >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorformula_erase" "', argument " "2"" of type '" "std::vector< spot::formula >::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 '" "vectorformula_erase" "', argument " "3"" of type '" "std::vector< spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::formula >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorformula_erase" "', argument " "3"" of type '" "std::vector< spot::formula >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_formula_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorformula_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorformula_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorformula_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorformula_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::formula >::erase(std::vector< spot::formula >::iterator)\n"
    "    std::vector< spot::formula >::erase(std::vector< spot::formula >::iterator,std::vector< spot::formula >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_vectorformula__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula >::size_type arg1 ;
  std::vector< spot::formula >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< spot::formula > *result = 0 ;
  
  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_vectorformula" "', argument " "1"" of type '" "std::vector< spot::formula >::size_type""'");
  } 
  arg1 = static_cast< std::vector< spot::formula >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vectorformula" "', argument " "2"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorformula" "', argument " "2"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::formula >::value_type * >(argp2);
  {
    try {
      result = (std::vector< spot::formula > *)new std::vector< spot::formula >(arg1,(std::vector< spot::formula >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_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_vectorformula(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vectorformula", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vectorformula__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vectorformula__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vectorformula__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vectorformula__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vectorformula'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::formula >::vector()\n"
    "    std::vector< spot::formula >::vector(std::vector< spot::formula > const &)\n"
    "    std::vector< spot::formula >::vector(std::vector< spot::formula >::size_type)\n"
    "    std::vector< spot::formula >::vector(std::vector< spot::formula >::size_type,std::vector< spot::formula >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorformula_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorformula_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_push_back" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorformula_push_back" "', argument " "2"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorformula_push_back" "', argument " "2"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::formula >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< spot::formula >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_front" "', argument " "1"" of type '" "std::vector< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = (std::vector< spot::formula >::value_type *) &((std::vector< spot::formula > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__formula, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::formula >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_back" "', argument " "1"" of type '" "std::vector< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = (std::vector< spot::formula >::value_type *) &((std::vector< spot::formula > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__formula, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::formula >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::size_type arg2 ;
  std::vector< spot::formula >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorformula_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_assign" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula_assign" "', argument " "2"" of type '" "std::vector< spot::formula >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorformula_assign" "', argument " "3"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorformula_assign" "', argument " "3"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::formula >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< spot::formula >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::size_type arg2 ;
  std::vector< spot::formula >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_resize" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula_resize" "', argument " "2"" of type '" "std::vector< spot::formula >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorformula_resize" "', argument " "3"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorformula_resize" "', argument " "3"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::formula >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< spot::formula >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorformula_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorformula_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorformula_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorformula_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::formula >::resize(std::vector< spot::formula >::size_type)\n"
    "    std::vector< spot::formula >::resize(std::vector< spot::formula >::size_type,std::vector< spot::formula >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorformula_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::iterator arg2 ;
  std::vector< spot::formula >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< spot::formula >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_insert" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(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 '" "vectorformula_insert" "', argument " "2"" of type '" "std::vector< spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::formula >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorformula_insert" "', argument " "2"" of type '" "std::vector< spot::formula >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorformula_insert" "', argument " "3"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorformula_insert" "', argument " "3"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::formula >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_spot_formula_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(spot::formula const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::formula >::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_vectorformula_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::iterator arg2 ;
  std::vector< spot::formula >::size_type arg3 ;
  std::vector< spot::formula >::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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_insert" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(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 '" "vectorformula_insert" "', argument " "2"" of type '" "std::vector< spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::formula >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorformula_insert" "', argument " "2"" of type '" "std::vector< spot::formula >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorformula_insert" "', argument " "3"" of type '" "std::vector< spot::formula >::size_type""'");
  } 
  arg3 = static_cast< std::vector< spot::formula >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectorformula_insert" "', argument " "4"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorformula_insert" "', argument " "4"" of type '" "std::vector< spot::formula >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< spot::formula >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_spot_formula_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(spot::formula const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorformula_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorformula_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorformula_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorformula_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::formula >::insert(std::vector< spot::formula >::iterator,std::vector< spot::formula >::value_type const &)\n"
    "    std::vector< spot::formula >::insert(std::vector< spot::formula >::iterator,std::vector< spot::formula >::size_type,std::vector< spot::formula >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorformula_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  std::vector< spot::formula >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorformula_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_reserve" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorformula_reserve" "', argument " "2"" of type '" "std::vector< spot::formula >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::formula >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorformula_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorformula_capacity" "', argument " "1"" of type '" "std::vector< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      result = ((std::vector< spot::formula > const *)arg1)->capacity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vectorformula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::formula > *arg1 = (std::vector< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectorformula" "', argument " "1"" of type '" "std::vector< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::formula > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vectorformula_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vectorformula_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_vectorunsigned_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 *swig_obj[3] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorunsigned___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___getslice__" "', 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 '" "vectorunsigned___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(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 '" "vectorunsigned___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 '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 '" "vectorunsigned___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 '" "vectorunsigned___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 '" "vectorunsigned___setslice__" "', argument " "4"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorunsigned___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorunsigned___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorunsigned___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorunsigned___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_vectorunsigned___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorunsigned___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___delslice__" "', 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 '" "vectorunsigned___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(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 '" "vectorunsigned___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 '" "vectorunsigned___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 '" "vectorunsigned___setitem__" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 '" "vectorunsigned___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 '" "vectorunsigned___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorunsigned___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorunsigned___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorunsigned___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorunsigned___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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorunsigned___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorunsigned___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorunsigned___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorunsigned___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__getitem__(PySliceObject *)\n"
    "    std::vector< unsigned int >::__getitem__(std::vector< unsigned int >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned___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 '" "vectorunsigned___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 '" "vectorunsigned___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorunsigned___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorunsigned___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vectorunsigned___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorunsigned___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorunsigned___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__setitem__(PySliceObject *,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
    "    std::vector< unsigned int >::__setitem__(PySliceObject *)\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_vectorunsigned_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorunsigned_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_append" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorunsigned__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorunsigned__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 ;
  
  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_vectorunsigned" "', argument " "1"" of type '" "std::vector< unsigned int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorunsigned" "', 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_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_vectorunsigned_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorunsigned_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_swap" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorunsigned_swap" "', argument " "2"" of type '" "std::vector< unsigned int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorunsigned_swap" "', argument " "2"" of type '" "std::vector< unsigned int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< unsigned int > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_begin" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorunsigned_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_end" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorunsigned_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_rbegin" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorunsigned_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_rend" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorunsigned_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_clear" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorunsigned__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 ;
  
  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_vectorunsigned" "', 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 >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_pop_back" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 '" "vectorunsigned_resize" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 '" "vectorunsigned_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 '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorunsigned_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 '" "vectorunsigned_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 '" "vectorunsigned_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 '" "vectorunsigned_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 '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorunsigned_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorunsigned_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorunsigned_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorunsigned_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorunsigned_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_vectorunsigned__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 ;
  
  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_vectorunsigned" "', 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_vectorunsigned" "', 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 >(arg1,(std::vector< unsigned int >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorunsigned(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vectorunsigned", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vectorunsigned__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vectorunsigned__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vectorunsigned__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vectorunsigned__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vectorunsigned'.\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_vectorunsigned_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorunsigned_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_push_back" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorunsigned_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_assign" "', 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 '" "vectorunsigned_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(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorunsigned_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(arg2,(std::vector< unsigned int >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 '" "vectorunsigned_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 '" "vectorunsigned_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(arg2,(std::vector< unsigned int >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorunsigned_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorunsigned_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorunsigned_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorunsigned_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_vectorunsigned_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 '" "vectorunsigned_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 '" "vectorunsigned_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 '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorunsigned_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 '" "vectorunsigned_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 '" "vectorunsigned_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 '" "vectorunsigned_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 '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorunsigned_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorunsigned_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorunsigned_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorunsigned_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_vectorunsigned_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorunsigned_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_reserve" "', 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 '" "vectorunsigned_reserve" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorunsigned_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorunsigned_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vectorunsigned(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectorunsigned" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vectorunsigned_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vectorunsigned_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_vectorpairunsigned_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_iterator" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___nonzero__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____nonzero__((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___bool__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____bool__((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___len__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____len__((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorpairunsigned___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___getslice__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned___getslice__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,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 '" "vectorpairunsigned___getslice__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,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 '" "vectorpairunsigned___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg3 ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,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 '" "vectorpairunsigned___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val3);
  {
    std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *ptr = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectorpairunsigned___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorpairunsigned___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorpairunsigned___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorpairunsigned___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorpairunsigned___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorpairunsigned___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__setslice__(std::vector< std::pair< unsigned int,unsigned int > >::difference_type,std::vector< std::pair< unsigned int,unsigned int > >::difference_type)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__setslice__(std::vector< std::pair< unsigned int,unsigned int > >::difference_type,std::vector< std::pair< unsigned int,unsigned int > >::difference_type,std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorpairunsigned___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___delslice__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned___delslice__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,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 '" "vectorpairunsigned___delslice__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned___delitem__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorpairunsigned___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorpairunsigned___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *ptr = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorpairunsigned___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorpairunsigned___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorpairunsigned___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorpairunsigned___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorpairunsigned___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorpairunsigned___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorpairunsigned___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorpairunsigned___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__delitem__(std::vector< std::pair< unsigned int,unsigned int > >::difference_type)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned___getitem__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::pair< unsigned int,unsigned int > >::value_type *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____getitem____SWIG_1((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< unsigned int,unsigned int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorpairunsigned___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorpairunsigned___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorpairunsigned___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorpairunsigned___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__getitem__(PySliceObject *)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__getitem__(std::vector< std::pair< unsigned int,unsigned int > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::difference_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned___setitem__" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::difference_type >(val2);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorpairunsigned___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorpairunsigned___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::pair< unsigned int,unsigned int > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorpairunsigned___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorpairunsigned___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vectorpairunsigned___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorpairunsigned___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorpairunsigned___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__setitem__(PySliceObject *,std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > const &)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__setitem__(PySliceObject *)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::__setitem__(std::vector< std::pair< unsigned int,unsigned int > >::difference_type,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_pop" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorpairunsigned_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_append" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorpairunsigned_append" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorpairunsigned_append" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__append(arg1,(std::pair< unsigned int,unsigned int > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorpairunsigned__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > > *)new std::vector< std::pair< unsigned int,unsigned int > >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorpairunsigned__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *ptr = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vectorpairunsigned" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorpairunsigned" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > > *)new std::vector< std::pair< unsigned int,unsigned int > >((std::vector< std::pair< unsigned int,unsigned int > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_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_vectorpairunsigned_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_empty" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_size" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorpairunsigned_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_swap" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorpairunsigned_swap" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorpairunsigned_swap" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_begin" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_end" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_rbegin" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_rend" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_clear" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< unsigned int,unsigned int > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_get_allocator" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::pair< unsigned int,unsigned int > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorpairunsigned__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  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_vectorpairunsigned" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > > *)new std::vector< std::pair< unsigned int,unsigned int > >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_pop_back" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_resize" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned_resize" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_erase" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,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 '" "vectorpairunsigned_erase" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorpairunsigned_erase" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator arg2 ;
  std::vector< std::pair< unsigned int,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::pair< unsigned int,unsigned int > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_erase" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,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 '" "vectorpairunsigned_erase" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorpairunsigned_erase" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,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 '" "vectorpairunsigned_erase" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorpairunsigned_erase" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorpairunsigned_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorpairunsigned_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorpairunsigned_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorpairunsigned_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::erase(std::vector< std::pair< unsigned int,unsigned int > >::iterator)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::erase(std::vector< std::pair< unsigned int,unsigned int > >::iterator,std::vector< std::pair< unsigned int,unsigned int > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_vectorpairunsigned__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg1 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::pair< unsigned int,unsigned int > > *result = 0 ;
  
  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_vectorpairunsigned" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val1);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vectorpairunsigned" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorpairunsigned" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > > *)new std::vector< std::pair< unsigned int,unsigned int > >(arg1,(std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_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_vectorpairunsigned(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vectorpairunsigned", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vectorpairunsigned__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vectorpairunsigned__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vectorpairunsigned__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vectorpairunsigned__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vectorpairunsigned'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::vector()\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::vector(std::vector< std::pair< unsigned int,unsigned int > > const &)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::vector(std::vector< std::pair< unsigned int,unsigned int > >::size_type)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::vector(std::vector< std::pair< unsigned int,unsigned int > >::size_type,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorpairunsigned_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_push_back" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorpairunsigned_push_back" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorpairunsigned_push_back" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_front" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > >::value_type *) &((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< unsigned int,unsigned int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_back" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int > >::value_type *) &((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::pair< unsigned int,unsigned int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorpairunsigned_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_assign" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned_assign" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val2);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorpairunsigned_assign" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorpairunsigned_assign" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_resize" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned_resize" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val2);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorpairunsigned_resize" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorpairunsigned_resize" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorpairunsigned_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorpairunsigned_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorpairunsigned_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorpairunsigned_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::resize(std::vector< std::pair< unsigned int,unsigned int > >::size_type)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::resize(std::vector< std::pair< unsigned int,unsigned int > >::size_type,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator arg2 ;
  std::vector< std::pair< unsigned int,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::pair< unsigned int,unsigned int > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_insert" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,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 '" "vectorpairunsigned_insert" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorpairunsigned_insert" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
    }
  }
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorpairunsigned_insert" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorpairunsigned_insert" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::pair< unsigned int,unsigned int > const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< unsigned int,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_vectorpairunsigned_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::iterator arg2 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg3 ;
  std::vector< std::pair< unsigned int,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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_insert" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,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 '" "vectorpairunsigned_insert" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< unsigned int,unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorpairunsigned_insert" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorpairunsigned_insert" "', argument " "3"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val3);
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,unsigned int > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectorpairunsigned_insert" "', argument " "4"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorpairunsigned_insert" "', argument " "4"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_unsigned_SS_int_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::pair< unsigned int,unsigned int > const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorpairunsigned_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorpairunsigned_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorpairunsigned_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorpairunsigned_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::insert(std::vector< std::pair< unsigned int,unsigned int > >::iterator,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)\n"
    "    std::vector< std::pair< unsigned int,unsigned int > >::insert(std::vector< std::pair< unsigned int,unsigned int > >::iterator,std::vector< std::pair< unsigned int,unsigned int > >::size_type,std::vector< std::pair< unsigned int,unsigned int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorpairunsigned_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_reserve" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorpairunsigned_reserve" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< unsigned int,unsigned int > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorpairunsigned_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorpairunsigned_capacity" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< unsigned int,unsigned int > > const *)arg1)->capacity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vectorpairunsigned(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< unsigned int,unsigned int > > *arg1 = (std::vector< std::pair< unsigned int,unsigned int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectorpairunsigned" "', argument " "1"" of type '" "std::vector< std::pair< unsigned int,unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< unsigned int,unsigned int > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vectorpairunsigned_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vectorpairunsigned_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_vectoracccond_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_iterator" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_spot_acc_cond_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___nonzero__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_acc_cond_Sg____nonzero__((std::vector< spot::acc_cond > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___bool__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_acc_cond_Sg____bool__((std::vector< spot::acc_cond > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___len__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = std_vector_Sl_spot_acc_cond_Sg____len__((std::vector< spot::acc_cond > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::difference_type arg2 ;
  std::vector< spot::acc_cond >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccond___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___getslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond___getslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectoracccond___getslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *)std_vector_Sl_spot_acc_cond_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::difference_type arg2 ;
  std::vector< spot::acc_cond >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___setslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond___setslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectoracccond___setslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::difference_type arg2 ;
  std::vector< spot::acc_cond >::difference_type arg3 ;
  std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___setslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond___setslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectoracccond___setslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond >::difference_type >(val3);
  {
    std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *ptr = (std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectoracccond___setslice__" "', argument " "4"" of type '" "std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccond___setslice__" "', argument " "4"" of type '" "std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccond___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccond___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectoracccond___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccond___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond >::__setslice__(std::vector< spot::acc_cond >::difference_type,std::vector< spot::acc_cond >::difference_type)\n"
    "    std::vector< spot::acc_cond >::__setslice__(std::vector< spot::acc_cond >::difference_type,std::vector< spot::acc_cond >::difference_type,std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccond___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::difference_type arg2 ;
  std::vector< spot::acc_cond >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccond___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___delslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond___delslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectoracccond___delslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___delitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond___delitem__" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___getitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccond___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *)std_vector_Sl_spot_acc_cond_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___setitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccond___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *ptr = (std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectoracccond___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccond___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___setitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccond___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___delitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccond___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccond___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectoracccond___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectoracccond___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccond___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond >::__delitem__(std::vector< spot::acc_cond >::difference_type)\n"
    "    std::vector< spot::acc_cond >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccond___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< spot::acc_cond >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___getitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond___getitem__" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< spot::acc_cond >::value_type *) &std_vector_Sl_spot_acc_cond_Sg____getitem____SWIG_1((std::vector< spot::acc_cond > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::acc_cond >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccond___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectoracccond___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectoracccond___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccond___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond >::__getitem__(PySliceObject *)\n"
    "    std::vector< spot::acc_cond >::__getitem__(std::vector< spot::acc_cond >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccond___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::difference_type arg2 ;
  std::vector< spot::acc_cond >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond___setitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond___setitem__" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectoracccond___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccond___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(spot::acc_cond const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccond___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectoracccond___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< spot::acc_cond,std::allocator< spot::acc_cond > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vectoracccond___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccond___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccond___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond >::__setitem__(PySliceObject *,std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > const &)\n"
    "    std::vector< spot::acc_cond >::__setitem__(PySliceObject *)\n"
    "    std::vector< spot::acc_cond >::__setitem__(std::vector< spot::acc_cond >::difference_type,std::vector< spot::acc_cond >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccond_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_pop" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_spot_acc_cond_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::acc_cond >::value_type(result)), SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccond_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_append" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectoracccond_append" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccond_append" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_spot_acc_cond_Sg__append(arg1,(spot::acc_cond const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectoracccond__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< spot::acc_cond > *)new std::vector< spot::acc_cond >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectoracccond__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< spot::acc_cond > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *ptr = (std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vectoracccond" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectoracccond" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< spot::acc_cond > *)new std::vector< spot::acc_cond >((std::vector< spot::acc_cond > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_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_vectoracccond_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_empty" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = (bool)((std::vector< spot::acc_cond > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_size" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = ((std::vector< spot::acc_cond > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccond_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_swap" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectoracccond_swap" "', argument " "2"" of type '" "std::vector< spot::acc_cond > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccond_swap" "', argument " "2"" of type '" "std::vector< spot::acc_cond > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_begin" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_end" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_rbegin" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_rend" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_clear" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< spot::acc_cond > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_get_allocator" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = ((std::vector< spot::acc_cond > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::acc_cond >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_spot__acc_cond_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectoracccond__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< spot::acc_cond > *result = 0 ;
  
  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_vectoracccond" "', argument " "1"" of type '" "std::vector< spot::acc_cond >::size_type""'");
  } 
  arg1 = static_cast< std::vector< spot::acc_cond >::size_type >(val1);
  {
    try {
      result = (std::vector< spot::acc_cond > *)new std::vector< spot::acc_cond >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_pop_back" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_resize" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond_resize" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< spot::acc_cond >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_erase" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(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 '" "vectoracccond_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccond_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_acc_cond_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::iterator arg2 ;
  std::vector< spot::acc_cond >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< spot::acc_cond >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_erase" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(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 '" "vectoracccond_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccond_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::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 '" "vectoracccond_erase" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccond_erase" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_acc_cond_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccond_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectoracccond_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccond_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccond_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond >::erase(std::vector< spot::acc_cond >::iterator)\n"
    "    std::vector< spot::acc_cond >::erase(std::vector< spot::acc_cond >::iterator,std::vector< spot::acc_cond >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_vectoracccond__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond >::size_type arg1 ;
  std::vector< spot::acc_cond >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< spot::acc_cond > *result = 0 ;
  
  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_vectoracccond" "', argument " "1"" of type '" "std::vector< spot::acc_cond >::size_type""'");
  } 
  arg1 = static_cast< std::vector< spot::acc_cond >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vectoracccond" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectoracccond" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond >::value_type * >(argp2);
  {
    try {
      result = (std::vector< spot::acc_cond > *)new std::vector< spot::acc_cond >(arg1,(std::vector< spot::acc_cond >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectoracccond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vectoracccond", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vectoracccond__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vectoracccond__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vectoracccond__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vectoracccond__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vectoracccond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond >::vector()\n"
    "    std::vector< spot::acc_cond >::vector(std::vector< spot::acc_cond > const &)\n"
    "    std::vector< spot::acc_cond >::vector(std::vector< spot::acc_cond >::size_type)\n"
    "    std::vector< spot::acc_cond >::vector(std::vector< spot::acc_cond >::size_type,std::vector< spot::acc_cond >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccond_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccond_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_push_back" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectoracccond_push_back" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccond_push_back" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< spot::acc_cond >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_front" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = (std::vector< spot::acc_cond >::value_type *) &((std::vector< spot::acc_cond > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::acc_cond >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_back" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = (std::vector< spot::acc_cond >::value_type *) &((std::vector< spot::acc_cond > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::acc_cond >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::size_type arg2 ;
  std::vector< spot::acc_cond >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccond_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_assign" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond_assign" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectoracccond_assign" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccond_assign" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< spot::acc_cond >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::size_type arg2 ;
  std::vector< spot::acc_cond >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_resize" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond_resize" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectoracccond_resize" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccond_resize" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< spot::acc_cond >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccond_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectoracccond_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccond_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccond_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond >::resize(std::vector< spot::acc_cond >::size_type)\n"
    "    std::vector< spot::acc_cond >::resize(std::vector< spot::acc_cond >::size_type,std::vector< spot::acc_cond >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccond_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::iterator arg2 ;
  std::vector< spot::acc_cond >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< spot::acc_cond >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_insert" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(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 '" "vectoracccond_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccond_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectoracccond_insert" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccond_insert" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_spot_acc_cond_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(spot::acc_cond const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::iterator arg2 ;
  std::vector< spot::acc_cond >::size_type arg3 ;
  std::vector< spot::acc_cond >::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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_insert" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(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 '" "vectoracccond_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccond_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectoracccond_insert" "', argument " "3"" of type '" "std::vector< spot::acc_cond >::size_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectoracccond_insert" "', argument " "4"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccond_insert" "', argument " "4"" of type '" "std::vector< spot::acc_cond >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< spot::acc_cond >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_spot_acc_cond_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(spot::acc_cond const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccond_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccond_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectoracccond_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccond_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond >::insert(std::vector< spot::acc_cond >::iterator,std::vector< spot::acc_cond >::value_type const &)\n"
    "    std::vector< spot::acc_cond >::insert(std::vector< spot::acc_cond >::iterator,std::vector< spot::acc_cond >::size_type,std::vector< spot::acc_cond >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccond_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  std::vector< spot::acc_cond >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccond_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_reserve" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccond_reserve" "', argument " "2"" of type '" "std::vector< spot::acc_cond >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccond_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccond_capacity" "', argument " "1"" of type '" "std::vector< spot::acc_cond > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      result = ((std::vector< spot::acc_cond > const *)arg1)->capacity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vectoracccond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond > *arg1 = (std::vector< spot::acc_cond > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectoracccond" "', argument " "1"" of type '" "std::vector< spot::acc_cond > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vectoracccond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vectoracccond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_vectoracccode_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_iterator" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_spot_acc_cond_acc_code_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___nonzero__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_acc_cond_acc_code_Sg____nonzero__((std::vector< spot::acc_cond::acc_code > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___bool__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_acc_cond_acc_code_Sg____bool__((std::vector< spot::acc_cond::acc_code > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___len__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = std_vector_Sl_spot_acc_cond_acc_code_Sg____len__((std::vector< spot::acc_cond::acc_code > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg2 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccode___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___getslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode___getslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectoracccode___getslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *)std_vector_Sl_spot_acc_cond_acc_code_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg2 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___setslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode___setslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectoracccode___setslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_acc_code_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg2 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg3 ;
  std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___setslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode___setslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectoracccode___setslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val3);
  {
    std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *ptr = (std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectoracccode___setslice__" "', argument " "4"" of type '" "std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccode___setslice__" "', argument " "4"" of type '" "std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_acc_code_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccode___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccode___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectoracccode___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccode___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::acc_code >::__setslice__(std::vector< spot::acc_cond::acc_code >::difference_type,std::vector< spot::acc_cond::acc_code >::difference_type)\n"
    "    std::vector< spot::acc_cond::acc_code >::__setslice__(std::vector< spot::acc_cond::acc_code >::difference_type,std::vector< spot::acc_cond::acc_code >::difference_type,std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccode___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg2 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccode___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___delslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode___delslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectoracccode___delslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_acc_code_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___delitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode___delitem__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_acc_code_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___getitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccode___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *)std_vector_Sl_spot_acc_cond_acc_code_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___setitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccode___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *ptr = (std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectoracccode___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccode___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_acc_code_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___setitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccode___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_acc_code_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___delitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccode___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_acc_code_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccode___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectoracccode___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectoracccode___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccode___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::acc_code >::__delitem__(std::vector< spot::acc_cond::acc_code >::difference_type)\n"
    "    std::vector< spot::acc_cond::acc_code >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccode___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< spot::acc_cond::acc_code >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___getitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode___getitem__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< spot::acc_cond::acc_code >::value_type *) &std_vector_Sl_spot_acc_cond_acc_code_Sg____getitem____SWIG_1((std::vector< spot::acc_cond::acc_code > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::acc_cond::acc_code >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccode___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectoracccode___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectoracccode___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccode___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::acc_code >::__getitem__(PySliceObject *)\n"
    "    std::vector< spot::acc_cond::acc_code >::__getitem__(std::vector< spot::acc_cond::acc_code >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccode___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::difference_type arg2 ;
  std::vector< spot::acc_cond::acc_code >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode___setitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode___setitem__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectoracccode___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccode___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond::acc_code >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_acc_code_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(spot::acc_cond::acc_code const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccode___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectoracccode___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vectoracccode___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccode___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccode___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccode___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::acc_code >::__setitem__(PySliceObject *,std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > const &)\n"
    "    std::vector< spot::acc_cond::acc_code >::__setitem__(PySliceObject *)\n"
    "    std::vector< spot::acc_cond::acc_code >::__setitem__(std::vector< spot::acc_cond::acc_code >::difference_type,std::vector< spot::acc_cond::acc_code >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccode_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_pop" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_spot_acc_cond_acc_code_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::acc_cond::acc_code >::value_type(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccode_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_append" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectoracccode_append" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccode_append" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond::acc_code >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_spot_acc_cond_acc_code_Sg__append(arg1,(spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectoracccode__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< spot::acc_cond::acc_code > *)new std::vector< spot::acc_cond::acc_code >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectoracccode__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< spot::acc_cond::acc_code > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *ptr = (std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vectoracccode" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectoracccode" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< spot::acc_cond::acc_code > *)new std::vector< spot::acc_cond::acc_code >((std::vector< spot::acc_cond::acc_code > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_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_vectoracccode_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_empty" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = (bool)((std::vector< spot::acc_cond::acc_code > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_size" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = ((std::vector< spot::acc_cond::acc_code > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccode_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_swap" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectoracccode_swap" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccode_swap" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_begin" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::acc_code >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_end" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::acc_code >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_rbegin" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::acc_code >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_rend" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::acc_code >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_clear" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< spot::acc_cond::acc_code > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_get_allocator" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = ((std::vector< spot::acc_cond::acc_code > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::acc_cond::acc_code >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_spot__acc_cond__acc_code_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectoracccode__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< spot::acc_cond::acc_code > *result = 0 ;
  
  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_vectoracccode" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code >::size_type""'");
  } 
  arg1 = static_cast< std::vector< spot::acc_cond::acc_code >::size_type >(val1);
  {
    try {
      result = (std::vector< spot::acc_cond::acc_code > *)new std::vector< spot::acc_cond::acc_code >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_pop_back" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_resize" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode_resize" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< spot::acc_cond::acc_code >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_erase" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(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 '" "vectoracccode_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond::acc_code >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond::acc_code >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccode_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_acc_cond_acc_code_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::acc_code >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::iterator arg2 ;
  std::vector< spot::acc_cond::acc_code >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< spot::acc_cond::acc_code >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_erase" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(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 '" "vectoracccode_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond::acc_code >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond::acc_code >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccode_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::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 '" "vectoracccode_erase" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond::acc_code >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond::acc_code >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccode_erase" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_acc_cond_acc_code_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::acc_code >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccode_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectoracccode_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccode_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccode_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::acc_code >::erase(std::vector< spot::acc_cond::acc_code >::iterator)\n"
    "    std::vector< spot::acc_cond::acc_code >::erase(std::vector< spot::acc_cond::acc_code >::iterator,std::vector< spot::acc_cond::acc_code >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_vectoracccode__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code >::size_type arg1 ;
  std::vector< spot::acc_cond::acc_code >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< spot::acc_cond::acc_code > *result = 0 ;
  
  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_vectoracccode" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code >::size_type""'");
  } 
  arg1 = static_cast< std::vector< spot::acc_cond::acc_code >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vectoracccode" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectoracccode" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond::acc_code >::value_type * >(argp2);
  {
    try {
      result = (std::vector< spot::acc_cond::acc_code > *)new std::vector< spot::acc_cond::acc_code >(arg1,(std::vector< spot::acc_cond::acc_code >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_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_vectoracccode(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vectoracccode", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vectoracccode__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vectoracccode__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vectoracccode__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vectoracccode__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vectoracccode'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::acc_code >::vector()\n"
    "    std::vector< spot::acc_cond::acc_code >::vector(std::vector< spot::acc_cond::acc_code > const &)\n"
    "    std::vector< spot::acc_cond::acc_code >::vector(std::vector< spot::acc_cond::acc_code >::size_type)\n"
    "    std::vector< spot::acc_cond::acc_code >::vector(std::vector< spot::acc_cond::acc_code >::size_type,std::vector< spot::acc_cond::acc_code >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccode_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccode_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_push_back" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectoracccode_push_back" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccode_push_back" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond::acc_code >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< spot::acc_cond::acc_code >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_front" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = (std::vector< spot::acc_cond::acc_code >::value_type *) &((std::vector< spot::acc_cond::acc_code > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::acc_cond::acc_code >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_back" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = (std::vector< spot::acc_cond::acc_code >::value_type *) &((std::vector< spot::acc_cond::acc_code > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::acc_cond::acc_code >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::size_type arg2 ;
  std::vector< spot::acc_cond::acc_code >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccode_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_assign" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode_assign" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectoracccode_assign" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccode_assign" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond::acc_code >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< spot::acc_cond::acc_code >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::size_type arg2 ;
  std::vector< spot::acc_cond::acc_code >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_resize" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode_resize" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectoracccode_resize" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccode_resize" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond::acc_code >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< spot::acc_cond::acc_code >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccode_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectoracccode_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccode_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccode_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::acc_code >::resize(std::vector< spot::acc_cond::acc_code >::size_type)\n"
    "    std::vector< spot::acc_cond::acc_code >::resize(std::vector< spot::acc_cond::acc_code >::size_type,std::vector< spot::acc_cond::acc_code >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccode_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::iterator arg2 ;
  std::vector< spot::acc_cond::acc_code >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< spot::acc_cond::acc_code >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_insert" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(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 '" "vectoracccode_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond::acc_code >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond::acc_code >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccode_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectoracccode_insert" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccode_insert" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond::acc_code >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_spot_acc_cond_acc_code_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(spot::acc_cond::acc_code const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::acc_code >::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_vectoracccode_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::iterator arg2 ;
  std::vector< spot::acc_cond::acc_code >::size_type arg3 ;
  std::vector< spot::acc_cond::acc_code >::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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_insert" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(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 '" "vectoracccode_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond::acc_code >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond::acc_code >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectoracccode_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectoracccode_insert" "', argument " "3"" of type '" "std::vector< spot::acc_cond::acc_code >::size_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond::acc_code >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectoracccode_insert" "', argument " "4"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectoracccode_insert" "', argument " "4"" of type '" "std::vector< spot::acc_cond::acc_code >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< spot::acc_cond::acc_code >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_spot_acc_cond_acc_code_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(spot::acc_cond::acc_code const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectoracccode_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectoracccode_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectoracccode_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectoracccode_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::acc_code >::insert(std::vector< spot::acc_cond::acc_code >::iterator,std::vector< spot::acc_cond::acc_code >::value_type const &)\n"
    "    std::vector< spot::acc_cond::acc_code >::insert(std::vector< spot::acc_cond::acc_code >::iterator,std::vector< spot::acc_cond::acc_code >::size_type,std::vector< spot::acc_cond::acc_code >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectoracccode_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  std::vector< spot::acc_cond::acc_code >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectoracccode_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_reserve" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectoracccode_reserve" "', argument " "2"" of type '" "std::vector< spot::acc_cond::acc_code >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::acc_code >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectoracccode_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectoracccode_capacity" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      result = ((std::vector< spot::acc_cond::acc_code > const *)arg1)->capacity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vectoracccode(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::acc_code > *arg1 = (std::vector< spot::acc_cond::acc_code > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectoracccode" "', argument " "1"" of type '" "std::vector< spot::acc_cond::acc_code > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::acc_code > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vectoracccode_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vectoracccode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_vectorbool_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_iterator" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_bool_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___nonzero__" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_bool_Sg____nonzero__((std::vector< bool > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___bool__" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_bool_Sg____bool__((std::vector< bool > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___len__" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = std_vector_Sl_bool_Sg____len__((std::vector< bool > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbool___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___getslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool___getslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbool___getslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___setslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool___setslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbool___setslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_bool_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  std::vector< bool,std::allocator< bool > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___setslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool___setslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbool___setslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectorbool___setslice__" "', argument " "4"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbool___setslice__" "', argument " "4"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_bool_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< bool,std::allocator< bool > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbool___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorbool___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorbool___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbool___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::__setslice__(std::vector< bool >::difference_type,std::vector< bool >::difference_type)\n"
    "    std::vector< bool >::__setslice__(std::vector< bool >::difference_type,std::vector< bool >::difference_type,std::vector< bool,std::allocator< bool > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbool___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbool___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___delslice__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool___delslice__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbool___delslice__" "', argument " "3"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_bool_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___delitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool___delitem__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_bool_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___getitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbool___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< bool,std::allocator< bool > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___setitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbool___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorbool___setitem__" "', argument " "3"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbool___setitem__" "', argument " "3"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_bool_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< bool,std::allocator< bool > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___setitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbool___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_bool_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___delitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbool___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_bool_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbool___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorbool___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorbool___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbool___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::__delitem__(std::vector< bool >::difference_type)\n"
    "    std::vector< bool >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbool___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< bool >::value_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___getitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool___getitem__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< bool >::value_type)std_vector_Sl_bool_Sg____getitem____SWIG_1(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbool___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorbool___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorbool___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbool___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::__getitem__(PySliceObject *)\n"
    "    std::vector< bool >::__getitem__(std::vector< bool >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbool___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::difference_type arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool___setitem__" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool___setitem__" "', argument " "2"" of type '" "std::vector< bool >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::difference_type >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbool___setitem__" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  {
    try {
      try {
        std_vector_Sl_bool_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbool___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorbool___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector<bool,std::allocator< bool > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vectorbool___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorbool___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbool___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::__setitem__(PySliceObject *,std::vector< bool,std::allocator< bool > > const &)\n"
    "    std::vector< bool >::__setitem__(PySliceObject *)\n"
    "    std::vector< bool >::__setitem__(std::vector< bool >::difference_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbool_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_pop" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      try {
        result = (std::vector< bool >::value_type)std_vector_Sl_bool_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbool_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_append" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool_append" "', argument " "2"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::value_type >(val2);
  {
    try {
      std_vector_Sl_bool_Sg__append(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorbool__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< bool > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorbool__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< bool > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vectorbool" "', argument " "1"" of type '" "std::vector< bool > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorbool" "', argument " "1"" of type '" "std::vector< bool > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >((std::vector< bool > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_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_vectorbool_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_empty" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (bool)((std::vector< bool > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_size" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = ((std::vector< bool > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbool_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_swap" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorbool_swap" "', argument " "2"" of type '" "std::vector< bool > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbool_swap" "', argument " "2"" of type '" "std::vector< bool > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bool > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_begin" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_end" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_rbegin" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_rend" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_clear" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< bool > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_get_allocator" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = ((std::vector< bool > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< bool >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_bool_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorbool__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< bool > *result = 0 ;
  
  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_vectorbool" "', argument " "1"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg1 = static_cast< std::vector< bool >::size_type >(val1);
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_pop_back" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_resize" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool_resize" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< bool >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_erase" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(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 '" "vectorbool_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbool_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_bool_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  std::vector< bool >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< bool >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_erase" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(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 '" "vectorbool_erase" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbool_erase" "', argument " "2"" of type '" "std::vector< bool >::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 '" "vectorbool_erase" "', argument " "3"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbool_erase" "', argument " "3"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_bool_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbool_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorbool_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorbool_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbool_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::erase(std::vector< bool >::iterator)\n"
    "    std::vector< bool >::erase(std::vector< bool >::iterator,std::vector< bool >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_vectorbool__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool >::size_type arg1 ;
  std::vector< bool >::value_type arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::vector< bool > *result = 0 ;
  
  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_vectorbool" "', argument " "1"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg1 = static_cast< std::vector< bool >::size_type >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_vectorbool" "', argument " "2"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::value_type >(val2);
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorbool(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vectorbool", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vectorbool__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vectorbool__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vectorbool__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vectorbool__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vectorbool'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::vector()\n"
    "    std::vector< bool >::vector(std::vector< bool > const &)\n"
    "    std::vector< bool >::vector(std::vector< bool >::size_type)\n"
    "    std::vector< bool >::vector(std::vector< bool >::size_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbool_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbool_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_push_back" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool_push_back" "', argument " "2"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::value_type >(val2);
  {
    try {
      (arg1)->push_back(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_front" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (std::vector< bool >::value_type)((std::vector< bool > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_back" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = (std::vector< bool >::value_type)((std::vector< bool > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbool_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_assign" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool_assign" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbool_assign" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  {
    try {
      (arg1)->assign(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_resize" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool_resize" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbool_resize" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  {
    try {
      (arg1)->resize(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbool_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorbool_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorbool_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbool_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::resize(std::vector< bool >::size_type)\n"
    "    std::vector< bool >::resize(std::vector< bool >::size_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbool_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  std::vector< bool >::value_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::vector< bool >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_insert" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(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 '" "vectorbool_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbool_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbool_insert" "', argument " "3"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::value_type >(val3);
  {
    try {
      result = std_vector_Sl_bool_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bool >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::iterator arg2 ;
  std::vector< bool >::size_type arg3 ;
  std::vector< bool >::value_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_insert" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(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 '" "vectorbool_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bool >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bool >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbool_insert" "', argument " "2"" of type '" "std::vector< bool >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbool_insert" "', argument " "3"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg3 = static_cast< std::vector< bool >::size_type >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vectorbool_insert" "', argument " "4"" of type '" "std::vector< bool >::value_type""'");
  } 
  arg4 = static_cast< std::vector< bool >::value_type >(val4);
  {
    try {
      std_vector_Sl_bool_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbool_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorbool_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorbool_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbool_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bool >::insert(std::vector< bool >::iterator,std::vector< bool >::value_type)\n"
    "    std::vector< bool >::insert(std::vector< bool >::iterator,std::vector< bool >::size_type,std::vector< bool >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbool_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  std::vector< bool >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbool_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_reserve" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbool_reserve" "', argument " "2"" of type '" "std::vector< bool >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bool >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbool_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbool_capacity" "', argument " "1"" of type '" "std::vector< bool > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      result = ((std::vector< bool > const *)arg1)->capacity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vectorbool(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectorbool" "', argument " "1"" of type '" "std::vector< bool > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vectorbool_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vectorbool_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_vectorbdd_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_iterator" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_bdd_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___nonzero__" "', argument " "1"" of type '" "std::vector< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_bdd_Sg____nonzero__((std::vector< bdd > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___bool__" "', argument " "1"" of type '" "std::vector< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_bdd_Sg____bool__((std::vector< bdd > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bdd >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___len__" "', argument " "1"" of type '" "std::vector< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = std_vector_Sl_bdd_Sg____len__((std::vector< bdd > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::difference_type arg2 ;
  std::vector< bdd >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< bdd,std::allocator< bdd > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbdd___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___getslice__" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd___getslice__" "', argument " "2"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbdd___getslice__" "', argument " "3"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bdd >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< bdd,std::allocator< bdd > > *)std_vector_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::difference_type arg2 ;
  std::vector< bdd >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___setslice__" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd___setslice__" "', argument " "2"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbdd___setslice__" "', argument " "3"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bdd >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::difference_type arg2 ;
  std::vector< bdd >::difference_type arg3 ;
  std::vector< bdd,std::allocator< bdd > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___setslice__" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd___setslice__" "', argument " "2"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbdd___setslice__" "', argument " "3"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bdd >::difference_type >(val3);
  {
    std::vector< bdd,std::allocator< bdd > > *ptr = (std::vector< bdd,std::allocator< bdd > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectorbdd___setslice__" "', argument " "4"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbdd___setslice__" "', argument " "4"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_bdd_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< bdd,std::allocator< bdd > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbdd___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorbdd___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorbdd___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbdd___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bdd >::__setslice__(std::vector< bdd >::difference_type,std::vector< bdd >::difference_type)\n"
    "    std::vector< bdd >::__setslice__(std::vector< bdd >::difference_type,std::vector< bdd >::difference_type,std::vector< bdd,std::allocator< bdd > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbdd___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::difference_type arg2 ;
  std::vector< bdd >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbdd___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___delslice__" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd___delslice__" "', argument " "2"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbdd___delslice__" "', argument " "3"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< bdd >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___delitem__" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd___delitem__" "', argument " "2"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< bdd,std::allocator< bdd > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___getitem__" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbdd___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< bdd,std::allocator< bdd > > *)std_vector_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< bdd,std::allocator< bdd > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___setitem__" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbdd___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< bdd,std::allocator< bdd > > *ptr = (std::vector< bdd,std::allocator< bdd > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorbdd___setitem__" "', argument " "3"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbdd___setitem__" "', argument " "3"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_bdd_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< bdd,std::allocator< bdd > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___setitem__" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbdd___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___delitem__" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbdd___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbdd___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorbdd___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorbdd___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbdd___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bdd >::__delitem__(std::vector< bdd >::difference_type)\n"
    "    std::vector< bdd >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbdd___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< bdd >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___getitem__" "', argument " "1"" of type '" "std::vector< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd___getitem__" "', argument " "2"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< bdd >::value_type *) &std_vector_Sl_bdd_Sg____getitem____SWIG_1((std::vector< bdd > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bdd, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< bdd >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbdd___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorbdd___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorbdd___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbdd___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bdd >::__getitem__(PySliceObject *)\n"
    "    std::vector< bdd >::__getitem__(std::vector< bdd >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbdd___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::difference_type arg2 ;
  std::vector< bdd >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd___setitem__" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd___setitem__" "', argument " "2"" of type '" "std::vector< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorbdd___setitem__" "', argument " "3"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbdd___setitem__" "', argument " "3"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< bdd >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_bdd_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(bdd const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbdd___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorbdd___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< bdd,std::allocator< bdd > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vectorbdd___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorbdd___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbdd___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bdd >::__setitem__(PySliceObject *,std::vector< bdd,std::allocator< bdd > > const &)\n"
    "    std::vector< bdd >::__setitem__(PySliceObject *)\n"
    "    std::vector< bdd >::__setitem__(std::vector< bdd >::difference_type,std::vector< bdd >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbdd_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bdd >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_pop" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_bdd_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< bdd >::value_type(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbdd_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_append" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorbdd_append" "', argument " "2"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbdd_append" "', argument " "2"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bdd >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_bdd_Sg__append(arg1,(bdd const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorbdd__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< bdd > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< bdd > *)new std::vector< bdd >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorbdd__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< bdd > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< bdd,std::allocator< bdd > > *ptr = (std::vector< bdd,std::allocator< bdd > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vectorbdd" "', argument " "1"" of type '" "std::vector< bdd > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorbdd" "', argument " "1"" of type '" "std::vector< bdd > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< bdd > *)new std::vector< bdd >((std::vector< bdd > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_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_vectorbdd_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_empty" "', argument " "1"" of type '" "std::vector< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = (bool)((std::vector< bdd > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bdd >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_size" "', argument " "1"" of type '" "std::vector< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = ((std::vector< bdd > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbdd_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_swap" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorbdd_swap" "', argument " "2"" of type '" "std::vector< bdd > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbdd_swap" "', argument " "2"" of type '" "std::vector< bdd > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bdd > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bdd >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_begin" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bdd >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bdd >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_end" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bdd >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bdd >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_rbegin" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bdd >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bdd >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_rend" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bdd >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_clear" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< bdd > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_get_allocator" "', argument " "1"" of type '" "std::vector< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = ((std::vector< bdd > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< bdd >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_bdd_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorbdd__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< bdd > *result = 0 ;
  
  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_vectorbdd" "', argument " "1"" of type '" "std::vector< bdd >::size_type""'");
  } 
  arg1 = static_cast< std::vector< bdd >::size_type >(val1);
  {
    try {
      result = (std::vector< bdd > *)new std::vector< bdd >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_pop_back" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_resize" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd_resize" "', argument " "2"" of type '" "std::vector< bdd >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< bdd >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_erase" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(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 '" "vectorbdd_erase" "', argument " "2"" of type '" "std::vector< bdd >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bdd >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bdd >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbdd_erase" "', argument " "2"" of type '" "std::vector< bdd >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_bdd_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bdd >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::iterator arg2 ;
  std::vector< bdd >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< bdd >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_erase" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(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 '" "vectorbdd_erase" "', argument " "2"" of type '" "std::vector< bdd >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bdd >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bdd >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbdd_erase" "', argument " "2"" of type '" "std::vector< bdd >::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 '" "vectorbdd_erase" "', argument " "3"" of type '" "std::vector< bdd >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bdd >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bdd >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbdd_erase" "', argument " "3"" of type '" "std::vector< bdd >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_bdd_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bdd >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbdd_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorbdd_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorbdd_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbdd_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bdd >::erase(std::vector< bdd >::iterator)\n"
    "    std::vector< bdd >::erase(std::vector< bdd >::iterator,std::vector< bdd >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_vectorbdd__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd >::size_type arg1 ;
  std::vector< bdd >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< bdd > *result = 0 ;
  
  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_vectorbdd" "', argument " "1"" of type '" "std::vector< bdd >::size_type""'");
  } 
  arg1 = static_cast< std::vector< bdd >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vectorbdd" "', argument " "2"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorbdd" "', argument " "2"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bdd >::value_type * >(argp2);
  {
    try {
      result = (std::vector< bdd > *)new std::vector< bdd >(arg1,(std::vector< bdd >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorbdd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vectorbdd", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vectorbdd__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vectorbdd__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vectorbdd__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vectorbdd__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vectorbdd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bdd >::vector()\n"
    "    std::vector< bdd >::vector(std::vector< bdd > const &)\n"
    "    std::vector< bdd >::vector(std::vector< bdd >::size_type)\n"
    "    std::vector< bdd >::vector(std::vector< bdd >::size_type,std::vector< bdd >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbdd_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbdd_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_push_back" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorbdd_push_back" "', argument " "2"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbdd_push_back" "', argument " "2"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bdd >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< bdd >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bdd >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_front" "', argument " "1"" of type '" "std::vector< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = (std::vector< bdd >::value_type *) &((std::vector< bdd > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bdd, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< bdd >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bdd >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_back" "', argument " "1"" of type '" "std::vector< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = (std::vector< bdd >::value_type *) &((std::vector< bdd > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bdd, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< bdd >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::size_type arg2 ;
  std::vector< bdd >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbdd_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_assign" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd_assign" "', argument " "2"" of type '" "std::vector< bdd >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorbdd_assign" "', argument " "3"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbdd_assign" "', argument " "3"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< bdd >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< bdd >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::size_type arg2 ;
  std::vector< bdd >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_resize" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd_resize" "', argument " "2"" of type '" "std::vector< bdd >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorbdd_resize" "', argument " "3"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbdd_resize" "', argument " "3"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< bdd >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< bdd >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbdd_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorbdd_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorbdd_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbdd_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bdd >::resize(std::vector< bdd >::size_type)\n"
    "    std::vector< bdd >::resize(std::vector< bdd >::size_type,std::vector< bdd >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbdd_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::iterator arg2 ;
  std::vector< bdd >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< bdd >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_insert" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(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 '" "vectorbdd_insert" "', argument " "2"" of type '" "std::vector< bdd >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bdd >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bdd >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbdd_insert" "', argument " "2"" of type '" "std::vector< bdd >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorbdd_insert" "', argument " "3"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbdd_insert" "', argument " "3"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< bdd >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_bdd_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(bdd const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< bdd >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::iterator arg2 ;
  std::vector< bdd >::size_type arg3 ;
  std::vector< bdd >::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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_insert" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(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 '" "vectorbdd_insert" "', argument " "2"" of type '" "std::vector< bdd >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< bdd >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< bdd >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorbdd_insert" "', argument " "2"" of type '" "std::vector< bdd >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorbdd_insert" "', argument " "3"" of type '" "std::vector< bdd >::size_type""'");
  } 
  arg3 = static_cast< std::vector< bdd >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectorbdd_insert" "', argument " "4"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorbdd_insert" "', argument " "4"" of type '" "std::vector< bdd >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< bdd >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_bdd_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(bdd const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorbdd_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorbdd_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorbdd_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorbdd_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< bdd >::insert(std::vector< bdd >::iterator,std::vector< bdd >::value_type const &)\n"
    "    std::vector< bdd >::insert(std::vector< bdd >::iterator,std::vector< bdd >::size_type,std::vector< bdd >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorbdd_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  std::vector< bdd >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorbdd_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_reserve" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorbdd_reserve" "', argument " "2"" of type '" "std::vector< bdd >::size_type""'");
  } 
  arg2 = static_cast< std::vector< bdd >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorbdd_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bdd >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorbdd_capacity" "', argument " "1"" of type '" "std::vector< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      result = ((std::vector< bdd > const *)arg1)->capacity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vectorbdd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< bdd > *arg1 = (std::vector< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectorbdd" "', argument " "1"" of type '" "std::vector< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< bdd > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vectorbdd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vectorbdd_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_aliasvector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_iterator" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___nonzero__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____nonzero__((std::vector< std::pair< std::string,bdd > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___bool__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____bool__((std::vector< std::pair< std::string,bdd > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< std::string,bdd > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___len__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____len__((std::vector< std::pair< std::string,bdd > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg2 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "aliasvector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___getslice__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector___getslice__" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aliasvector___getslice__" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *)std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg2 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aliasvector___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg2 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg3 ;
  std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___setslice__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector___setslice__" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aliasvector___setslice__" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val3);
  {
    std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *ptr = (std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "aliasvector___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aliasvector___setslice__" "', argument " "4"" of type '" "std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aliasvector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_aliasvector___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_aliasvector___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aliasvector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< std::string,bdd > >::__setslice__(std::vector< std::pair< std::string,bdd > >::difference_type,std::vector< std::pair< std::string,bdd > >::difference_type)\n"
    "    std::vector< std::pair< std::string,bdd > >::__setslice__(std::vector< std::pair< std::string,bdd > >::difference_type,std::vector< std::pair< std::string,bdd > >::difference_type,std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aliasvector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg2 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aliasvector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___delslice__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector___delslice__" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aliasvector___delslice__" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector___delitem__" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "aliasvector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *)std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "aliasvector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *ptr = (std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aliasvector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aliasvector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "aliasvector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___delitem__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "aliasvector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aliasvector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_aliasvector___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_aliasvector___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aliasvector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< std::string,bdd > >::__delitem__(std::vector< std::pair< std::string,bdd > >::difference_type)\n"
    "    std::vector< std::pair< std::string,bdd > >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aliasvector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::pair< std::string,bdd > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___getitem__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector___getitem__" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::pair< std::string,bdd > >::value_type *) &std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____getitem____SWIG_1((std::vector< std::pair< std::string,bdd > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_bdd_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< std::pair< std::string,bdd > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aliasvector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_aliasvector___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_aliasvector___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aliasvector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< std::string,bdd > >::__getitem__(PySliceObject *)\n"
    "    std::vector< std::pair< std::string,bdd > >::__getitem__(std::vector< std::pair< std::string,bdd > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aliasvector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::difference_type arg2 ;
  std::vector< std::pair< std::string,bdd > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector___setitem__" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector___setitem__" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__pairT_std__string_bdd_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aliasvector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aliasvector___setitem__" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::pair< std::string,bdd > >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::pair< std::string,bdd > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aliasvector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aliasvector___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_aliasvector___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_aliasvector___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aliasvector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< std::string,bdd > >::__setitem__(PySliceObject *,std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > const &)\n"
    "    std::vector< std::pair< std::string,bdd > >::__setitem__(PySliceObject *)\n"
    "    std::vector< std::pair< std::string,bdd > >::__setitem__(std::vector< std::pair< std::string,bdd > >::difference_type,std::vector< std::pair< std::string,bdd > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aliasvector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::pair< std::string,bdd > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_pop" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::pair< std::string,bdd > >::value_type(result)), SWIGTYPE_p_std__pairT_std__string_bdd_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aliasvector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_append" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__pairT_std__string_bdd_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aliasvector_append" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aliasvector_append" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,bdd > >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__append(arg1,(std::pair< std::string,bdd > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_aliasvector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::pair< std::string,bdd > > *)new std::vector< std::pair< std::string,bdd > >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_aliasvector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::pair< std::string,bdd > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *ptr = (std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_aliasvector" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_aliasvector" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::pair< std::string,bdd > > *)new std::vector< std::pair< std::string,bdd > >((std::vector< std::pair< std::string,bdd > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_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_aliasvector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_empty" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::pair< std::string,bdd > > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< std::string,bdd > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_size" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< std::string,bdd > > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aliasvector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_swap" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aliasvector_swap" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aliasvector_swap" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< std::string,bdd > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_begin" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< std::string,bdd > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< std::string,bdd > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_end" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< std::string,bdd > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< std::string,bdd > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_rbegin" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< std::string,bdd > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< std::string,bdd > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_rend" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< std::string,bdd > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_clear" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< std::string,bdd > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_get_allocator" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< std::string,bdd > > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::pair< std::string,bdd > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_std__string_bdd_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_aliasvector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::pair< std::string,bdd > > *result = 0 ;
  
  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_aliasvector" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< std::string,bdd > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::pair< std::string,bdd > > *)new std::vector< std::pair< std::string,bdd > >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_pop_back" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_resize" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector_resize" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::pair< std::string,bdd > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_erase" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(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 '" "aliasvector_erase" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< std::string,bdd > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< std::string,bdd > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "aliasvector_erase" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< std::string,bdd > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::iterator arg2 ;
  std::vector< std::pair< std::string,bdd > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::pair< std::string,bdd > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_erase" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(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 '" "aliasvector_erase" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< std::string,bdd > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< std::string,bdd > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "aliasvector_erase" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::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 '" "aliasvector_erase" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< std::string,bdd > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< std::string,bdd > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "aliasvector_erase" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< std::string,bdd > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aliasvector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aliasvector_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aliasvector_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aliasvector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< std::string,bdd > >::erase(std::vector< std::pair< std::string,bdd > >::iterator)\n"
    "    std::vector< std::pair< std::string,bdd > >::erase(std::vector< std::pair< std::string,bdd > >::iterator,std::vector< std::pair< std::string,bdd > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_aliasvector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > >::size_type arg1 ;
  std::vector< std::pair< std::string,bdd > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< std::pair< std::string,bdd > > *result = 0 ;
  
  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_aliasvector" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::pair< std::string,bdd > >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__pairT_std__string_bdd_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_aliasvector" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_aliasvector" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,bdd > >::value_type * >(argp2);
  {
    try {
      result = (std::vector< std::pair< std::string,bdd > > *)new std::vector< std::pair< std::string,bdd > >(arg1,(std::vector< std::pair< std::string,bdd > >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_aliasvector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_aliasvector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_aliasvector__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_aliasvector__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_aliasvector__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_aliasvector__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_aliasvector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< std::string,bdd > >::vector()\n"
    "    std::vector< std::pair< std::string,bdd > >::vector(std::vector< std::pair< std::string,bdd > > const &)\n"
    "    std::vector< std::pair< std::string,bdd > >::vector(std::vector< std::pair< std::string,bdd > >::size_type)\n"
    "    std::vector< std::pair< std::string,bdd > >::vector(std::vector< std::pair< std::string,bdd > >::size_type,std::vector< std::pair< std::string,bdd > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aliasvector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aliasvector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_push_back" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__pairT_std__string_bdd_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aliasvector_push_back" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aliasvector_push_back" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< std::string,bdd > >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< std::pair< std::string,bdd > >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< std::string,bdd > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_front" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< std::string,bdd > >::value_type *) &((std::vector< std::pair< std::string,bdd > > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_bdd_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< std::pair< std::string,bdd > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< std::string,bdd > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_back" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = (std::vector< std::pair< std::string,bdd > >::value_type *) &((std::vector< std::pair< std::string,bdd > > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_std__string_bdd_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< std::pair< std::string,bdd > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::size_type arg2 ;
  std::vector< std::pair< std::string,bdd > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aliasvector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_assign" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector_assign" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__pairT_std__string_bdd_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aliasvector_assign" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aliasvector_assign" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::pair< std::string,bdd > >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::pair< std::string,bdd > >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::size_type arg2 ;
  std::vector< std::pair< std::string,bdd > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_resize" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector_resize" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__pairT_std__string_bdd_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aliasvector_resize" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aliasvector_resize" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::pair< std::string,bdd > >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::pair< std::string,bdd > >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aliasvector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aliasvector_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aliasvector_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aliasvector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< std::string,bdd > >::resize(std::vector< std::pair< std::string,bdd > >::size_type)\n"
    "    std::vector< std::pair< std::string,bdd > >::resize(std::vector< std::pair< std::string,bdd > >::size_type,std::vector< std::pair< std::string,bdd > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aliasvector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::iterator arg2 ;
  std::vector< std::pair< std::string,bdd > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< std::pair< std::string,bdd > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_insert" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(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 '" "aliasvector_insert" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< std::string,bdd > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< std::string,bdd > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "aliasvector_insert" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__pairT_std__string_bdd_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aliasvector_insert" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aliasvector_insert" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::pair< std::string,bdd > >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::pair< std::string,bdd > const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::pair< std::string,bdd > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::iterator arg2 ;
  std::vector< std::pair< std::string,bdd > >::size_type arg3 ;
  std::vector< std::pair< std::string,bdd > >::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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_insert" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(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 '" "aliasvector_insert" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::pair< std::string,bdd > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::pair< std::string,bdd > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "aliasvector_insert" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aliasvector_insert" "', argument " "3"" of type '" "std::vector< std::pair< std::string,bdd > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::pair< std::string,bdd > >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__pairT_std__string_bdd_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "aliasvector_insert" "', argument " "4"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aliasvector_insert" "', argument " "4"" of type '" "std::vector< std::pair< std::string,bdd > >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::pair< std::string,bdd > >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_std_pair_Sl_std_string_Sc_bdd_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::pair< std::string,bdd > const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aliasvector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_aliasvector_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_aliasvector_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aliasvector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::pair< std::string,bdd > >::insert(std::vector< std::pair< std::string,bdd > >::iterator,std::vector< std::pair< std::string,bdd > >::value_type const &)\n"
    "    std::vector< std::pair< std::string,bdd > >::insert(std::vector< std::pair< std::string,bdd > >::iterator,std::vector< std::pair< std::string,bdd > >::size_type,std::vector< std::pair< std::string,bdd > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aliasvector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  std::vector< std::pair< std::string,bdd > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aliasvector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_reserve" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliasvector_reserve" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::pair< std::string,bdd > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliasvector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< std::string,bdd > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aliasvector_capacity" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      result = ((std::vector< std::pair< std::string,bdd > > const *)arg1)->capacity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_aliasvector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::pair< std::string,bdd > > *arg1 = (std::vector< std::pair< std::string,bdd > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_aliasvector" "', argument " "1"" of type '" "std::vector< std::pair< std::string,bdd > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< std::string,bdd > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *aliasvector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *aliasvector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_vectorstring_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 *swig_obj[3] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorstring___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___getslice__" "', 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 '" "vectorstring___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(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 '" "vectorstring___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 '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 '" "vectorstring___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 '" "vectorstring___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 '" "vectorstring___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorstring___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorstring___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorstring___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorstring___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_vectorstring___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorstring___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___delslice__" "', 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 '" "vectorstring___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(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 '" "vectorstring___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 '" "vectorstring___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 '" "vectorstring___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 '" "vectorstring___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 '" "vectorstring___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorstring___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorstring___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorstring___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorstring___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__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorstring___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorstring___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorstring___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorstring___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorstring___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__getitem__(PySliceObject *)\n"
    "    std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorstring___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring___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 '" "vectorstring___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 '" "vectorstring___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorstring___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorstring___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorstring___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vectorstring___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorstring___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorstring___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__setitem__(PySliceObject *,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    std::vector< std::string >::__setitem__(PySliceObject *)\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_vectorstring_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorstring_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorstring_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorstring__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorstring__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 ;
  
  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_vectorstring" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorstring" "', 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_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_vectorstring_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorstring_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_swap" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorstring_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorstring_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_begin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorstring_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_end" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorstring_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_rbegin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorstring_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_rend" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorstring_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorstring__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 ;
  
  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_vectorstring" "', 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 >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_pop_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 '" "vectorstring_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 '" "vectorstring_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 '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorstring_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 '" "vectorstring_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 '" "vectorstring_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 '" "vectorstring_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 '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorstring_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorstring_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorstring_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorstring_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorstring_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_vectorstring__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 ;
  
  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_vectorstring" "', 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_vectorstring" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorstring" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >(arg1,(std::vector< std::string >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_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_vectorstring(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vectorstring", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vectorstring__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vectorstring__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vectorstring__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vectorstring__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vectorstring'.\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_vectorstring_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorstring_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorstring_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  (void)swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorstring_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_assign" "', 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 '" "vectorstring_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(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vectorstring_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorstring_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::string >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 '" "vectorstring_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 '" "vectorstring_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorstring_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::string >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorstring_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorstring_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorstring_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorstring_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_vectorstring_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 '" "vectorstring_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 '" "vectorstring_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 '" "vectorstring_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorstring_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 '" "vectorstring_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 '" "vectorstring_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 '" "vectorstring_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 '" "vectorstring_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorstring_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorstring_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorstring_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorstring_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_vectorstring_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorstring_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_reserve" "', 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 '" "vectorstring_reserve" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorstring_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorstring_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vectorstring(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectorstring" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vectorstring_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vectorstring_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_vectorint_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 *swig_obj[3] ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorint___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___getslice__" "', 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 '" "vectorint___getslice__" "', 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 '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 '" "vectorint___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 '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 '" "vectorint___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 '" "vectorint___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 '" "vectorint___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorint___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorint___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorint___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorint___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_vectorint___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorint___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___delslice__" "', 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 '" "vectorint___delslice__" "', 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 '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 '" "vectorint___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< int,std::allocator< int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 '" "vectorint___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 '" "vectorint___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 '" "vectorint___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 '" "vectorint___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorint___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorint___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorint___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorint___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
    "    std::vector< int >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorint___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorint___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vectorint___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorint___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorint___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__getitem__(PySliceObject *)\n"
    "    std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorint___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint___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 '" "vectorint___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 '" "vectorint___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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorint___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorint___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vectorint___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorint___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorint___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__setitem__(PySliceObject *,std::vector< int,std::allocator< int > > const &)\n"
    "    std::vector< int >::__setitem__(PySliceObject *)\n"
    "    std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vectorint_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorint_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_append" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorint__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< int > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< int > *)new std::vector< int >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorint__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 ;
  
  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_vectorint" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorint" "', 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_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_vectorint_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorint_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_swap" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorint_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorint_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_begin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorint_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_end" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorint_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_rbegin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorint_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_rend" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorint_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorint__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 ;
  
  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_vectorint" "', 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 >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 '" "vectorint_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< int >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 '" "vectorint_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 '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorint_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 '" "vectorint_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 '" "vectorint_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 '" "vectorint_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 '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorint_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorint_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorint_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorint_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorint_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_vectorint__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 ;
  
  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_vectorint" "', 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_vectorint" "', 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 >(arg1,(std::vector< int >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vectorint(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vectorint", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vectorint__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vectorint__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vectorint__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vectorint__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vectorint'.\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_vectorint_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorint_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_push_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  (void)swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorint_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_assign" "', 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 '" "vectorint_assign" "', 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 '" "vectorint_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 '" "vectorint_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 '" "vectorint_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorint_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vectorint_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorint_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorint_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_vectorint_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 '" "vectorint_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 '" "vectorint_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 '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  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_vectorint_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 '" "vectorint_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 '" "vectorint_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 '" "vectorint_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 '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vectorint_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vectorint_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vectorint_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vectorint_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_vectorint_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vectorint_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_reserve" "', 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 '" "vectorint_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vectorint_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorint_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vectorint(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectorint" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vectorint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vectorint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pair_formula_vectorstring__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< spot::formula,std::vector< std::string > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< spot::formula,std::vector< std::string > > *)new std::pair< spot::formula,std::vector< std::string > >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pair_formula_vectorstring__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::vector< std::string,std::allocator< std::string > > arg2 ;
  std::pair< spot::formula,std::vector< std::string > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_pair_formula_vectorstring" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)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_pair_formula_vectorstring" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (std::pair< spot::formula,std::vector< std::string > > *)new std::pair< spot::formula,std::vector< std::string > >(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pair_formula_vectorstring__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< spot::formula,std::vector< std::string,std::allocator< std::string > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< spot::formula,std::vector< std::string > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< spot::formula,std::vector< std::string,std::allocator< std::string > > > *ptr = (std::pair< spot::formula,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_pair_formula_vectorstring" "', argument " "1"" of type '" "std::pair< spot::formula,std::vector< std::string,std::allocator< std::string > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pair_formula_vectorstring" "', argument " "1"" of type '" "std::pair< spot::formula,std::vector< std::string,std::allocator< std::string > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< spot::formula,std::vector< std::string > > *)new std::pair< spot::formula,std::vector< std::string > >((std::pair< spot::formula,std::vector< std::string,std::allocator< std::string > > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_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_new_pair_formula_vectorstring(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pair_formula_vectorstring", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_pair_formula_vectorstring__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_pair_formula_vectorstring__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_pair_formula_vectorstring__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pair_formula_vectorstring'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< spot::formula,std::vector< std::string > >::pair()\n"
    "    std::pair< spot::formula,std::vector< std::string > >::pair(spot::formula,std::vector< std::string,std::allocator< std::string > >)\n"
    "    std::pair< spot::formula,std::vector< std::string > >::pair(std::pair< spot::formula,std::vector< std::string,std::allocator< std::string > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_pair_formula_vectorstring_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< spot::formula,std::vector< std::string > > *arg1 = (std::pair< spot::formula,std::vector< std::string > > *) 0 ;
  spot::formula *arg2 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pair_formula_vectorstring_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_formula_vectorstring_first_set" "', argument " "1"" of type '" "std::pair< spot::formula,std::vector< std::string > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< spot::formula,std::vector< std::string > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pair_formula_vectorstring_first_set" "', argument " "2"" of type '" "spot::formula *""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  if (arg1) (arg1)->first = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pair_formula_vectorstring_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< spot::formula,std::vector< std::string > > *arg1 = (std::pair< spot::formula,std::vector< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_formula_vectorstring_first_get" "', argument " "1"" of type '" "std::pair< spot::formula,std::vector< std::string > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< spot::formula,std::vector< std::string > > * >(argp1);
  result = (spot::formula *)& ((arg1)->first);
  {
    if (!*result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(*result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pair_formula_vectorstring_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< spot::formula,std::vector< std::string > > *arg1 = (std::pair< spot::formula,std::vector< std::string > > *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pair_formula_vectorstring_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_formula_vectorstring_second_set" "', argument " "1"" of type '" "std::pair< spot::formula,std::vector< std::string > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< spot::formula,std::vector< std::string > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pair_formula_vectorstring_second_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->second = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pair_formula_vectorstring_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< spot::formula,std::vector< std::string > > *arg1 = (std::pair< spot::formula,std::vector< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_formula_vectorstring_second_get" "', argument " "1"" of type '" "std::pair< spot::formula,std::vector< std::string > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< spot::formula,std::vector< std::string > > * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->second);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_pair_formula_vectorstring(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< spot::formula,std::vector< std::string > > *arg1 = (std::pair< spot::formula,std::vector< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pair_formula_vectorstring" "', argument " "1"" of type '" "std::pair< spot::formula,std::vector< std::string > > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< spot::formula,std::vector< std::string > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *pair_formula_vectorstring_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pair_formula_vectorstring_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_atomic_prop_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< spot::formula > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::set< spot::formula > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_spot__formula_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_atomic_prop_set" "', argument " "1"" of type '" "std::less< spot::formula > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_atomic_prop_set" "', argument " "1"" of type '" "std::less< spot::formula > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< spot::formula > * >(argp1);
  {
    try {
      result = (std::set< spot::formula > *)new std::set< spot::formula >((std::less< spot::formula > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_iterator" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_set_Sl_spot_formula_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set___nonzero__" "', argument " "1"" of type '" "std::set< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = (bool)std_set_Sl_spot_formula_Sg____nonzero__((std::set< spot::formula > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set___bool__" "', argument " "1"" of type '" "std::set< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = (bool)std_set_Sl_spot_formula_Sg____bool__((std::set< spot::formula > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< spot::formula >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set___len__" "', argument " "1"" of type '" "std::set< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = std_set_Sl_spot_formula_Sg____len__((std::set< spot::formula > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_append" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "atomic_prop_set_append" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      std_set_Sl_spot_formula_Sg__append(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set___contains__" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "atomic_prop_set___contains__" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (bool)std_set_Sl_spot_formula_Sg____contains__(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::set< spot::formula >::value_type result;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set___getitem__" "', argument " "1"" of type '" "std::set< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "atomic_prop_set___getitem__" "', argument " "2"" of type '" "std::set< spot::formula >::difference_type""'");
  } 
  arg2 = static_cast< std::set< spot::formula >::difference_type >(val2);
  {
    try {
      try {
        result = std_set_Sl_spot_formula_Sg____getitem__((std::set< spot::formula > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_add(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set_add", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_add" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "atomic_prop_set_add" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      std_set_Sl_spot_formula_Sg__add(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_discard(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set_discard", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_discard" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "atomic_prop_set_discard" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      std_set_Sl_spot_formula_Sg__discard(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_atomic_prop_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::set< spot::formula > *)new std::set< spot::formula >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_atomic_prop_set__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::set< spot::formula > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *ptr = (std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_atomic_prop_set" "', argument " "1"" of type '" "std::set< spot::formula > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_atomic_prop_set" "', argument " "1"" of type '" "std::set< spot::formula > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::set< spot::formula > *)new std::set< spot::formula >((std::set< spot::formula > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_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_new_atomic_prop_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_atomic_prop_set", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_atomic_prop_set__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_spot__formula_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_atomic_prop_set__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_atomic_prop_set__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_atomic_prop_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::set< spot::formula >::set(std::less< spot::formula > const &)\n"
    "    std::set< spot::formula >::set()\n"
    "    std::set< spot::formula >::set(std::set< spot::formula > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_empty" "', argument " "1"" of type '" "std::set< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = (bool)((std::set< spot::formula > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< spot::formula >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_size" "', argument " "1"" of type '" "std::set< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = ((std::set< spot::formula > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_clear" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_swap" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "atomic_prop_set_swap" "', argument " "2"" of type '" "std::set< spot::formula > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "atomic_prop_set_swap" "', argument " "2"" of type '" "std::set< spot::formula > &""'"); 
  }
  arg2 = reinterpret_cast< std::set< spot::formula > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::set< spot::formula >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_erase" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "atomic_prop_set_erase" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "atomic_prop_set_erase" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< spot::formula >::key_type * >(argp2);
  {
    try {
      result = (arg1)->erase((std::set< spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::set< spot::formula >::size_type result;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_count" "', argument " "1"" of type '" "std::set< spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "atomic_prop_set_count" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "atomic_prop_set_count" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< spot::formula >::key_type * >(argp2);
  {
    try {
      result = ((std::set< spot::formula > const *)arg1)->count((std::set< spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< spot::formula >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_begin" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< spot::formula >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_end" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< spot::formula >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_rbegin" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< spot::formula >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< spot::formula >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_rend" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< spot::formula >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_erase" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(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 '" "atomic_prop_set_erase" "', argument " "2"" of type '" "std::set< spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::set< spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::set< spot::formula >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "atomic_prop_set_erase" "', argument " "2"" of type '" "std::set< spot::formula >::iterator""'");
    }
  }
  {
    try {
      std_set_Sl_spot_formula_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::iterator arg2 ;
  std::set< spot::formula >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_erase" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(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 '" "atomic_prop_set_erase" "', argument " "2"" of type '" "std::set< spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::set< spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::set< spot::formula >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "atomic_prop_set_erase" "', argument " "2"" of type '" "std::set< spot::formula >::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 '" "atomic_prop_set_erase" "', argument " "3"" of type '" "std::set< spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::set< spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::set< spot::formula >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "atomic_prop_set_erase" "', argument " "3"" of type '" "std::set< spot::formula >::iterator""'");
    }
  }
  {
    try {
      std_set_Sl_spot_formula_Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "atomic_prop_set_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__formula, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_atomic_prop_set_erase__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      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::set< spot::formula >::iterator > *>(iter) != 0));
    }
    if (!_v) goto check_2;
    return _wrap_atomic_prop_set_erase__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_atomic_prop_set_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_atomic_prop_set_erase__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'atomic_prop_set_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::set< spot::formula >::erase(std::set< spot::formula >::key_type const &)\n"
    "    std::set< spot::formula >::erase(std::set< spot::formula >::iterator)\n"
    "    std::set< spot::formula >::erase(std::set< spot::formula >::iterator,std::set< spot::formula >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::set< spot::formula >::iterator result;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_find" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "atomic_prop_set_find" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "atomic_prop_set_find" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< spot::formula >::key_type * >(argp2);
  {
    try {
      result = (arg1)->find((std::set< spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::set< spot::formula >::iterator result;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_lower_bound" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "atomic_prop_set_lower_bound" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "atomic_prop_set_lower_bound" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< spot::formula >::key_type * >(argp2);
  {
    try {
      result = (arg1)->lower_bound((std::set< spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::set< spot::formula >::iterator result;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_upper_bound" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "atomic_prop_set_upper_bound" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "atomic_prop_set_upper_bound" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< spot::formula >::key_type * >(argp2);
  {
    try {
      result = (arg1)->upper_bound((std::set< spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::set< spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_equal_range(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::pair< std::set< spot::formula >::iterator,std::set< spot::formula >::iterator > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set_equal_range", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_equal_range" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "atomic_prop_set_equal_range" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "atomic_prop_set_equal_range" "', argument " "2"" of type '" "std::set< spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< spot::formula >::key_type * >(argp2);
  {
    try {
      result = (arg1)->equal_range((std::set< spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = PyTuple_New(2);
  PyTuple_SetItem(resultobj,0,SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::pair< std::set< spot::formula >::iterator,std::set< spot::formula >::iterator > & >(result).first),
      swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
  PyTuple_SetItem(resultobj,1,SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::pair< std::set< spot::formula >::iterator,std::set< spot::formula >::iterator > & >(result).second),
      swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set_insert(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  std::set< spot::formula >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::pair< std::set< spot::formula >::iterator,bool > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_set_insert", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set_insert" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "atomic_prop_set_insert" "', argument " "2"" of type '" "std::set< spot::formula >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "atomic_prop_set_insert" "', argument " "2"" of type '" "std::set< spot::formula >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::set< spot::formula >::value_type * >(argp2);
  {
    try {
      result = (arg1)->insert((std::set< spot::formula >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = PyTuple_New(2);
  PyTuple_SetItem(resultobj,0,SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::pair< std::set< spot::formula >::iterator,bool > & >(result).first),
      swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN));    
  PyTuple_SetItem(resultobj,1,SWIG_From_bool  (static_cast< const std::pair< std::set< spot::formula >::iterator,bool > & >(result).second));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set___str__" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = std_set_Sl_spot_formula_Sg____str__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_set___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "atomic_prop_set___repr__" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      result = std_set_Sl_spot_formula_Sg____repr__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_atomic_prop_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::set< spot::formula > *arg1 = (std::set< spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_atomic_prop_set" "', argument " "1"" of type '" "std::set< spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::set< spot::formula > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *atomic_prop_set_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *atomic_prop_set_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_relabeling_map__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::less< spot::formula > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::map< spot::formula,spot::formula > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__lessT_spot__formula_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_relabeling_map" "', argument " "1"" of type '" "std::less< spot::formula > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_relabeling_map" "', argument " "1"" of type '" "std::less< spot::formula > const &""'"); 
  }
  arg1 = reinterpret_cast< std::less< spot::formula > * >(argp1);
  {
    try {
      result = (std::map< spot::formula,spot::formula > *)new std::map< spot::formula,spot::formula >((std::less< spot::formula > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_iterator" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_spot_formula_Sc_spot_formula_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map___nonzero__" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_spot_formula_Sc_spot_formula_Sg____nonzero__((std::map< spot::formula,spot::formula > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map___bool__" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (bool)std_map_Sl_spot_formula_Sc_spot_formula_Sg____bool__((std::map< spot::formula,spot::formula > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< spot::formula,spot::formula >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map___len__" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = std_map_Sl_spot_formula_Sc_spot_formula_Sg____len__((std::map< spot::formula,spot::formula > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map___getitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< spot::formula,spot::formula >::mapped_type *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "relabeling_map___getitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map___getitem__" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map___getitem__" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map___getitem__" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  {
    try {
      try {
        result = (std::map< spot::formula,spot::formula >::mapped_type *) &std_map_Sl_spot_formula_Sc_spot_formula_Sg____getitem__(arg1,(spot::formula const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__formula, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map___delitem__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "relabeling_map___delitem__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map___delitem__" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map___delitem__" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map___delitem__" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  {
    try {
      try {
        std_map_Sl_spot_formula_Sc_spot_formula_Sg____delitem__(arg1,(spot::formula const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_has_key(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "relabeling_map_has_key", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_has_key" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map_has_key" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map_has_key" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_spot_formula_Sc_spot_formula_Sg__has_key((std::map< spot::formula,spot::formula > const *)arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_keys(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_keys" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_spot_formula_Sc_spot_formula_Sg__keys(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_values(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_values" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_spot_formula_Sc_spot_formula_Sg__values(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_items(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_items" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_spot_formula_Sc_spot_formula_Sg__items(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map___contains__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "relabeling_map___contains__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map___contains__" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map___contains__" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map___contains__" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  {
    try {
      result = (bool)std_map_Sl_spot_formula_Sc_spot_formula_Sg____contains__(arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_key_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_key_iterator" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_spot_formula_Sc_spot_formula_Sg__key_iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_value_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_value_iterator" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_map_Sl_spot_formula_Sc_spot_formula_Sg__value_iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map___setitem__" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map___setitem__" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map___setitem__" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  {
    try {
      std_map_Sl_spot_formula_Sc_spot_formula_Sg____setitem____SWIG_0(arg1,(spot::formula const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  std::map< spot::formula,spot::formula >::mapped_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map___setitem__" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map___setitem__" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map___setitem__" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "relabeling_map___setitem__" "', argument " "3"" of type '" "std::map< spot::formula,spot::formula >::mapped_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map___setitem__" "', argument " "3"" of type '" "std::map< spot::formula,spot::formula >::mapped_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::map< spot::formula,spot::formula >::mapped_type * >(argp3);
  {
    try {
      try {
        std_map_Sl_spot_formula_Sc_spot_formula_Sg____setitem____SWIG_1(arg1,(spot::formula const &)*arg2,(spot::formula const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "relabeling_map___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_relabeling_map___setitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_relabeling_map___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'relabeling_map___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< spot::formula,spot::formula >::__setitem__(std::map< spot::formula,spot::formula >::key_type const &)\n"
    "    std::map< spot::formula,spot::formula >::__setitem__(std::map< spot::formula,spot::formula >::key_type const &,std::map< spot::formula,spot::formula >::mapped_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_relabeling_map_asdict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_asdict" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (PyObject *)std_map_Sl_spot_formula_Sc_spot_formula_Sg__asdict(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = result;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_relabeling_map__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::map< spot::formula,spot::formula > *)new std::map< spot::formula,spot::formula >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_relabeling_map__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::map< spot::formula,spot::formula > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > > *ptr = (std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_relabeling_map" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_relabeling_map" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::map< spot::formula,spot::formula > *)new std::map< spot::formula,spot::formula >((std::map< spot::formula,spot::formula > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_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_new_relabeling_map(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_relabeling_map", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_relabeling_map__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__lessT_spot__formula_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_relabeling_map__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_relabeling_map__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_relabeling_map'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< spot::formula,spot::formula >::map(std::less< spot::formula > const &)\n"
    "    std::map< spot::formula,spot::formula >::map()\n"
    "    std::map< spot::formula,spot::formula >::map(std::map< spot::formula,spot::formula > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_relabeling_map_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_empty" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (bool)((std::map< spot::formula,spot::formula > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< spot::formula,spot::formula >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_size" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = ((std::map< spot::formula,spot::formula > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "relabeling_map_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_swap" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map_swap" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map_swap" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula > &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< spot::formula,spot::formula >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_begin" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< spot::formula,spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< spot::formula,spot::formula >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_end" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< spot::formula,spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< spot::formula,spot::formula >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_rbegin" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< spot::formula,spot::formula >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::map< spot::formula,spot::formula >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_rend" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< spot::formula,spot::formula >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_clear" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::pair< spot::formula const,spot::formula > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_get_allocator" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      result = ((std::map< spot::formula,spot::formula > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::map< spot::formula,spot::formula >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::map< spot::formula,spot::formula >::size_type result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_erase" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map_erase" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map_erase" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  {
    try {
      result = (arg1)->erase((std::map< spot::formula,spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< spot::formula,spot::formula >::size_type result;
  
  if (!SWIG_Python_UnpackTuple(args, "relabeling_map_count", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_count" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > const *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map_count" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map_count" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  {
    try {
      result = ((std::map< spot::formula,spot::formula > const *)arg1)->count((std::map< spot::formula,spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_erase" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(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 '" "relabeling_map_erase" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< spot::formula,spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< spot::formula,spot::formula >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "relabeling_map_erase" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_spot_formula_Sc_spot_formula_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_erase__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::iterator arg2 ;
  std::map< spot::formula,spot::formula >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_erase" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(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 '" "relabeling_map_erase" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< spot::formula,spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< spot::formula,spot::formula >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "relabeling_map_erase" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::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 '" "relabeling_map_erase" "', argument " "3"" of type '" "std::map< spot::formula,spot::formula >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::map< spot::formula,spot::formula >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::map< spot::formula,spot::formula >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "relabeling_map_erase" "', argument " "3"" of type '" "std::map< spot::formula,spot::formula >::iterator""'");
    }
  }
  {
    try {
      std_map_Sl_spot_formula_Sc_spot_formula_Sg__erase__SWIG_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "relabeling_map_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__formula, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_relabeling_map_erase__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      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::map< spot::formula,spot::formula >::iterator > *>(iter) != 0));
    }
    if (!_v) goto check_2;
    return _wrap_relabeling_map_erase__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_relabeling_map_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_relabeling_map_erase__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'relabeling_map_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::map< spot::formula,spot::formula >::erase(std::map< spot::formula,spot::formula >::key_type const &)\n"
    "    std::map< spot::formula,spot::formula >::erase(std::map< spot::formula,spot::formula >::iterator)\n"
    "    std::map< spot::formula,spot::formula >::erase(std::map< spot::formula,spot::formula >::iterator,std::map< spot::formula,spot::formula >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_relabeling_map_find(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< spot::formula,spot::formula >::iterator result;
  
  if (!SWIG_Python_UnpackTuple(args, "relabeling_map_find", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_find" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map_find" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map_find" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  {
    try {
      result = (arg1)->find((std::map< spot::formula,spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< spot::formula,spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_lower_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< spot::formula,spot::formula >::iterator result;
  
  if (!SWIG_Python_UnpackTuple(args, "relabeling_map_lower_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_lower_bound" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map_lower_bound" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map_lower_bound" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  {
    try {
      result = (arg1)->lower_bound((std::map< spot::formula,spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< spot::formula,spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabeling_map_upper_bound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  std::map< spot::formula,spot::formula >::key_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::map< spot::formula,spot::formula >::iterator result;
  
  if (!SWIG_Python_UnpackTuple(args, "relabeling_map_upper_bound", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabeling_map_upper_bound" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabeling_map_upper_bound" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabeling_map_upper_bound" "', argument " "2"" of type '" "std::map< spot::formula,spot::formula >::key_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::map< spot::formula,spot::formula >::key_type * >(argp2);
  {
    try {
      result = (arg1)->upper_bound((std::map< spot::formula,spot::formula >::key_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::map< spot::formula,spot::formula >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_relabeling_map(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::map< spot::formula,spot::formula > *arg1 = (std::map< spot::formula,spot::formula > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_relabeling_map" "', argument " "1"" of type '" "std::map< spot::formula,spot::formula > *""'"); 
  }
  arg1 = reinterpret_cast< std::map< spot::formula,spot::formula > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *relabeling_map_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *relabeling_map_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_environment_require(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::environment *arg1 = (spot::environment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "environment_require", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__environment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "environment_require" "', argument " "1"" of type '" "spot::environment *""'"); 
  }
  arg1 = reinterpret_cast< spot::environment * >(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 '" "environment_require" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "environment_require" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (arg1)->require((std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_environment_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::environment *arg1 = (spot::environment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__environment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "environment_name" "', argument " "1"" of type '" "spot::environment const *""'"); 
  }
  arg1 = reinterpret_cast< spot::environment * >(argp1);
  {
    try {
      result = (std::string *) &((spot::environment const *)arg1)->name();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_environment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::environment *arg1 = (spot::environment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__environment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_environment" "', argument " "1"" of type '" "spot::environment *""'"); 
  }
  arg1 = reinterpret_cast< spot::environment * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *environment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__environment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_declarative_environment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::declarative_environment *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_declarative_environment", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::declarative_environment *)new spot::declarative_environment();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__declarative_environment, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_declarative_environment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::declarative_environment *arg1 = (spot::declarative_environment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__declarative_environment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_declarative_environment" "', argument " "1"" of type '" "spot::declarative_environment *""'"); 
  }
  arg1 = reinterpret_cast< spot::declarative_environment * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_declarative_environment_declare(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::declarative_environment *arg1 = (spot::declarative_environment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "declarative_environment_declare", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__declarative_environment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "declarative_environment_declare" "', argument " "1"" of type '" "spot::declarative_environment *""'"); 
  }
  arg1 = reinterpret_cast< spot::declarative_environment * >(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 '" "declarative_environment_declare" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "declarative_environment_declare" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (bool)(arg1)->declare((std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_declarative_environment_get_prop_map(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::declarative_environment *arg1 = (spot::declarative_environment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::declarative_environment::prop_map *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__declarative_environment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "declarative_environment_get_prop_map" "', argument " "1"" of type '" "spot::declarative_environment const *""'"); 
  }
  arg1 = reinterpret_cast< spot::declarative_environment * >(argp1);
  {
    try {
      result = (spot::declarative_environment::prop_map *) &((spot::declarative_environment const *)arg1)->get_prop_map();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_std__string_const_spot__formula_std__lessT_std__string_const_t_std__allocatorT_std__pairT_std__string_const_const_spot__formula_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *declarative_environment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__declarative_environment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *declarative_environment_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_default_environment(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::default_environment *arg1 = (spot::default_environment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__default_environment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_default_environment" "', argument " "1"" of type '" "spot::default_environment *""'"); 
  }
  arg1 = reinterpret_cast< spot::default_environment * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_default_environment_instance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::default_environment *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "default_environment_instance", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::default_environment *) &spot::default_environment::instance();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__default_environment, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *default_environment_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__default_environment, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_parse_error_list___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parse_error_list *arg1 = (spot::parse_error_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parse_error_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_error_list___nonzero__" "', argument " "1"" of type '" "spot::parse_error_list *""'"); 
  }
  arg1 = reinterpret_cast< spot::parse_error_list * >(argp1);
  {
    try {
      result = (bool)spot_parse_error_list___nonzero__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_error_list___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parse_error_list *arg1 = (spot::parse_error_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parse_error_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_error_list___bool__" "', argument " "1"" of type '" "spot::parse_error_list *""'"); 
  }
  arg1 = reinterpret_cast< spot::parse_error_list * >(argp1);
  {
    try {
      result = (bool)spot_parse_error_list___bool__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_parse_error_list(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parse_error_list *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_parse_error_list", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::parse_error_list *)new spot::parse_error_list();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__parse_error_list, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_parse_error_list(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parse_error_list *arg1 = (spot::parse_error_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parse_error_list, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_parse_error_list" "', argument " "1"" of type '" "spot::parse_error_list *""'"); 
  }
  arg1 = reinterpret_cast< spot::parse_error_list * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *parse_error_list_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__parse_error_list, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *parse_error_list_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_parsed_formula_f_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_formula *arg1 = (spot::parsed_formula *) 0 ;
  spot::formula *arg2 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_formula_f_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parsed_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_formula_f_set" "', argument " "1"" of type '" "spot::parsed_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::parsed_formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parsed_formula_f_set" "', argument " "2"" of type '" "spot::formula *""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  if (arg1) (arg1)->f = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_formula_f_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_formula *arg1 = (spot::parsed_formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parsed_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_formula_f_get" "', argument " "1"" of type '" "spot::parsed_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::parsed_formula * >(argp1);
  result = (spot::formula *)& ((arg1)->f);
  {
    if (!*result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(*result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_formula_input_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_formula *arg1 = (spot::parsed_formula *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_formula_input_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parsed_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_formula_input_set" "', argument " "1"" of type '" "spot::parsed_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::parsed_formula * >(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 '" "parsed_formula_input_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parsed_formula_input_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->input = *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_parsed_formula_input_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_formula *arg1 = (spot::parsed_formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parsed_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_formula_input_get" "', argument " "1"" of type '" "spot::parsed_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::parsed_formula * >(argp1);
  result = (std::string *) & ((arg1)->input);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_formula_errors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_formula *arg1 = (spot::parsed_formula *) 0 ;
  spot::parse_error_list *arg2 = (spot::parse_error_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_formula_errors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parsed_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_formula_errors_set" "', argument " "1"" of type '" "spot::parsed_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::parsed_formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__parse_error_list, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parsed_formula_errors_set" "', argument " "2"" of type '" "spot::parse_error_list *""'"); 
  }
  arg2 = reinterpret_cast< spot::parse_error_list * >(argp2);
  if (arg1) (arg1)->errors = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_formula_errors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_formula *arg1 = (spot::parsed_formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::parse_error_list *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parsed_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_formula_errors_get" "', argument " "1"" of type '" "spot::parsed_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::parsed_formula * >(argp1);
  result = (spot::parse_error_list *)& ((arg1)->errors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__parse_error_list, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_parsed_formula__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::parsed_formula *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_parsed_formula" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_parsed_formula" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (spot::parsed_formula *)new spot::parsed_formula((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__parsed_formula, 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_parsed_formula__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::parsed_formula *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::parsed_formula *)new spot::parsed_formula();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_parsed_formula(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_parsed_formula", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_parsed_formula__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_parsed_formula__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_parsed_formula'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::parsed_formula::parsed_formula(std::string const &)\n"
    "    spot::parsed_formula::parsed_formula()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_parsed_formula_format_errors__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::parsed_formula *arg1 = (spot::parsed_formula *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parsed_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_formula_format_errors" "', argument " "1"" of type '" "spot::parsed_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::parsed_formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parsed_formula_format_errors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parsed_formula_format_errors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (bool)(arg1)->format_errors(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_formula_format_errors__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::parsed_formula *arg1 = (spot::parsed_formula *) 0 ;
  std::ostream *arg2 = 0 ;
  std::string *arg3 = 0 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  bool result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parsed_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_formula_format_errors" "', argument " "1"" of type '" "spot::parsed_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::parsed_formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parsed_formula_format_errors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parsed_formula_format_errors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    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 '" "parsed_formula_format_errors" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parsed_formula_format_errors" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "parsed_formula_format_errors" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = (bool)(arg1)->format_errors(*arg2,(std::string const &)*arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_formula_format_errors(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "parsed_formula_format_errors", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_parsed_formula_format_errors__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_parsed_formula_format_errors__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'parsed_formula_format_errors'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::parsed_formula::format_errors(std::ostream &)\n"
    "    spot::parsed_formula::format_errors(std::ostream &,std::string const &,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_parsed_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_formula *arg1 = (spot::parsed_formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_parsed_formula" "', argument " "1"" of type '" "spot::parsed_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::parsed_formula * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *parsed_formula_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__parsed_formula, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *parsed_formula_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_parse_infix_psl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_psl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_psl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_infix_psl" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_psl" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "parse_infix_psl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "parse_infix_psl" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::parse_infix_psl((std::string const &)*arg1,*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_psl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_psl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_psl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_infix_psl" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_psl" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "parse_infix_psl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::parse_infix_psl((std::string const &)*arg1,*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_psl__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_psl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_psl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_infix_psl" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_psl" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  {
    try {
      result = spot::parse_infix_psl((std::string const &)*arg1,*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_psl__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::parsed_formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_psl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_psl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = spot::parse_infix_psl((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_psl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "parse_infix_psl", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_parse_infix_psl__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_parse_infix_psl__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_parse_infix_psl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_parse_infix_psl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'parse_infix_psl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::parse_infix_psl(std::string const &,spot::environment &,bool,bool)\n"
    "    spot::parse_infix_psl(std::string const &,spot::environment &,bool)\n"
    "    spot::parse_infix_psl(std::string const &,spot::environment &)\n"
    "    spot::parse_infix_psl(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_parse_infix_boolean__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_boolean" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_boolean" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_infix_boolean" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_boolean" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "parse_infix_boolean" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "parse_infix_boolean" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::parse_infix_boolean((std::string const &)*arg1,*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_boolean__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_boolean" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_boolean" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_infix_boolean" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_boolean" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "parse_infix_boolean" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::parse_infix_boolean((std::string const &)*arg1,*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_boolean__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_boolean" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_boolean" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_infix_boolean" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_boolean" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  {
    try {
      result = spot::parse_infix_boolean((std::string const &)*arg1,*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_boolean__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::parsed_formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_boolean" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_boolean" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = spot::parse_infix_boolean((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_boolean(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "parse_infix_boolean", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_parse_infix_boolean__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_parse_infix_boolean__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_parse_infix_boolean__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_parse_infix_boolean__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'parse_infix_boolean'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::parse_infix_boolean(std::string const &,spot::environment &,bool,bool)\n"
    "    spot::parse_infix_boolean(std::string const &,spot::environment &,bool)\n"
    "    spot::parse_infix_boolean(std::string const &,spot::environment &)\n"
    "    spot::parse_infix_boolean(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_parse_prefix_ltl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_prefix_ltl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_prefix_ltl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_prefix_ltl" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_prefix_ltl" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "parse_prefix_ltl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::parse_prefix_ltl((std::string const &)*arg1,*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_prefix_ltl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_prefix_ltl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_prefix_ltl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_prefix_ltl" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_prefix_ltl" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  {
    try {
      result = spot::parse_prefix_ltl((std::string const &)*arg1,*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_prefix_ltl__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::parsed_formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_prefix_ltl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_prefix_ltl" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = spot::parse_prefix_ltl((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_prefix_ltl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "parse_prefix_ltl", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_parse_prefix_ltl__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_parse_prefix_ltl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_parse_prefix_ltl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'parse_prefix_ltl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::parse_prefix_ltl(std::string const &,spot::environment &,bool)\n"
    "    spot::parse_prefix_ltl(std::string const &,spot::environment &)\n"
    "    spot::parse_prefix_ltl(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_parse_formula__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_formula" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_formula" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_formula" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_formula" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  {
    try {
      result = spot::parse_formula((std::string const &)*arg1,*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_formula__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_formula" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_formula" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = spot::parse_formula((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_formula(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "parse_formula", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_parse_formula__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_parse_formula__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'parse_formula'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::parse_formula(std::string const &,spot::environment &)\n"
    "    spot::parse_formula(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_parse_infix_sere__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_sere" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_sere" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_infix_sere" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_sere" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "parse_infix_sere" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "parse_infix_sere" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::parse_infix_sere((std::string const &)*arg1,*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_sere__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_sere" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_sere" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_infix_sere" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_sere" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "parse_infix_sere" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::parse_infix_sere((std::string const &)*arg1,*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_sere__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::environment *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::parsed_formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_sere" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_sere" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_infix_sere" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_sere" "', argument " "2"" of type '" "spot::environment &""'"); 
  }
  arg2 = reinterpret_cast< spot::environment * >(argp2);
  {
    try {
      result = spot::parse_infix_sere((std::string const &)*arg1,*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_sere__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::parsed_formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_infix_sere" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_infix_sere" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = spot::parse_infix_sere((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::parsed_formula(result)), SWIGTYPE_p_spot__parsed_formula, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_infix_sere(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "parse_infix_sere", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_parse_infix_sere__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_parse_infix_sere__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_parse_infix_sere__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_parse_infix_sere__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'parse_infix_sere'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::parse_infix_sere(std::string const &,spot::environment &,bool,bool)\n"
    "    spot::parse_infix_sere(std::string const &,spot::environment &,bool)\n"
    "    spot::parse_infix_sere(std::string const &,spot::environment &)\n"
    "    spot::parse_infix_sere(std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fix_utf8_locations(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::parse_error_list *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "fix_utf8_locations", 2, 2, swig_obj)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fix_utf8_locations" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fix_utf8_locations" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__parse_error_list,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fix_utf8_locations" "', argument " "2"" of type '" "spot::parse_error_list &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fix_utf8_locations" "', argument " "2"" of type '" "spot::parse_error_list &""'"); 
  }
  arg2 = reinterpret_cast< spot::parse_error_list * >(argp2);
  {
    try {
      spot::fix_utf8_locations((std::string const &)*arg1,*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_bdd_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_bdd_dict", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::bdd_dict *)new spot::bdd_dict();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::bdd_dict > *smartresult = result ? new std::shared_ptr<  spot::bdd_dict >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_bdd_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_bdd_dict" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_var_map_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  spot::bdd_dict::fv_map *arg2 = (spot::bdd_dict::fv_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_dict_var_map_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_var_map_set" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_dict_var_map_set" "', argument " "2"" of type '" "spot::bdd_dict::fv_map *""'"); 
  }
  arg2 = reinterpret_cast< spot::bdd_dict::fv_map * >(argp2);
  if (arg1) (arg1)->var_map = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_var_map_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::bdd_dict::fv_map *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_var_map_get" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::bdd_dict::fv_map *)& ((arg1)->var_map);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_acc_map_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  spot::bdd_dict::fv_map *arg2 = (spot::bdd_dict::fv_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_dict_acc_map_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_acc_map_set" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_dict_acc_map_set" "', argument " "2"" of type '" "spot::bdd_dict::fv_map *""'"); 
  }
  arg2 = reinterpret_cast< spot::bdd_dict::fv_map * >(argp2);
  if (arg1) (arg1)->acc_map = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_acc_map_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::bdd_dict::fv_map *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_acc_map_get" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::bdd_dict::fv_map *)& ((arg1)->acc_map);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_bdd_map_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  spot::bdd_dict::bdd_info_map *arg2 = (spot::bdd_dict::bdd_info_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_dict_bdd_map_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_bdd_map_set" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_spot__bdd_dict__bdd_info_std__allocatorT_spot__bdd_dict__bdd_info_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_dict_bdd_map_set" "', argument " "2"" of type '" "spot::bdd_dict::bdd_info_map *""'"); 
  }
  arg2 = reinterpret_cast< spot::bdd_dict::bdd_info_map * >(argp2);
  if (arg1) (arg1)->bdd_map = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_bdd_map_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::bdd_dict::bdd_info_map *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_bdd_map_get" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::bdd_dict::bdd_info_map *)& ((arg1)->bdd_map);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__bdd_dict__bdd_info_std__allocatorT_spot__bdd_dict__bdd_info_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_register_proposition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  spot::formula arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  int res3 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_register_proposition" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "bdd_dict_register_proposition" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_dict_register_proposition" "', argument " "3"" of type '" "void const *""'"); 
  }
  {
    try {
      result = (int)(arg1)->register_proposition(arg2,(void const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_has_registered_proposition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  spot::formula arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_dict_has_registered_proposition", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_has_registered_proposition" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "bdd_dict_has_registered_proposition" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_dict_has_registered_proposition" "', argument " "3"" of type '" "void const *""'"); 
  }
  {
    try {
      result = (int)(arg1)->has_registered_proposition(arg2,(void const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_varnum(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_dict_varnum", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_varnum" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "bdd_dict_varnum" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (int)(arg1)->varnum(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_register_acceptance_variable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  spot::formula arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  int res3 ;
  PyObject *swig_obj[3] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_dict_register_acceptance_variable", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_register_acceptance_variable" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "bdd_dict_register_acceptance_variable" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_dict_register_acceptance_variable" "', argument " "3"" of type '" "void const *""'"); 
  }
  {
    try {
      result = (int)(arg1)->register_acceptance_variable(arg2,(void const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_register_anonymous_variables__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  int arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_register_anonymous_variables" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bdd_dict_register_anonymous_variables" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_dict_register_anonymous_variables" "', argument " "3"" of type '" "void const *""'"); 
  }
  {
    try {
      result = (int)(arg1)->register_anonymous_variables(arg2,(void const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_register_all_variables_of__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  int res2 ;
  int res3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_register_all_variables_of" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_dict_register_all_variables_of" "', argument " "2"" of type '" "void const *""'"); 
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_dict_register_all_variables_of" "', argument " "3"" of type '" "void const *""'"); 
  }
  {
    try {
      (arg1)->register_all_variables_of((void const *)arg2,(void const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_unregister_all_my_variables__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  int res2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_unregister_all_my_variables" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_dict_unregister_all_my_variables" "', argument " "2"" of type '" "void const *""'"); 
  }
  {
    try {
      (arg1)->unregister_all_my_variables((void const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_unregister_variable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  int arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_unregister_variable" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bdd_dict_unregister_variable" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_dict_unregister_variable" "', argument " "3"" of type '" "void const *""'"); 
  }
  {
    try {
      (arg1)->unregister_variable(arg2,(void const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_dump(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict const > tempshared1 ;
  std::shared_ptr< spot::bdd_dict const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_dict_dump", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_dump" "', argument " "1"" of type '" "spot::bdd_dict const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_dict_dump" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_dict_dump" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::bdd_dict const *)arg1)->dump(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_assert_emptiness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict const > tempshared1 ;
  std::shared_ptr< spot::bdd_dict const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_assert_emptiness" "', argument " "1"" of type '" "spot::bdd_dict const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      ((spot::bdd_dict const *)arg1)->assert_emptiness();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  spot::bdd_dict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict const > tempshared1 ;
  std::shared_ptr< spot::bdd_dict const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::shared_ptr< spot::bdd_dict const > tempshared2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_dict___eq__", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict___eq__" "', argument " "1"" of type '" "spot::bdd_dict const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_dict___eq__" "', argument " "2"" of type '" "spot::bdd_dict const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_dict___eq__" "', argument " "2"" of type '" "spot::bdd_dict const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp2);
      delete reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp2);
      arg2 = const_cast< spot::bdd_dict * >(tempshared2.get());
    } else {
      arg2 = const_cast< spot::bdd_dict * >(reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp2)->get());
    }
  }
  {
    try {
      result = (bool)spot_bdd_dict_operator_Se__Se_((spot::bdd_dict const *)arg1,(spot::bdd_dict const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_bdd_dict___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  spot::bdd_dict *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict const > tempshared1 ;
  std::shared_ptr< spot::bdd_dict const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::shared_ptr< spot::bdd_dict const > tempshared2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_dict___ne__", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict___ne__" "', argument " "1"" of type '" "spot::bdd_dict const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_dict___ne__" "', argument " "2"" of type '" "spot::bdd_dict const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_dict___ne__" "', argument " "2"" of type '" "spot::bdd_dict const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp2);
      delete reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp2);
      arg2 = const_cast< spot::bdd_dict * >(tempshared2.get());
    } else {
      arg2 = const_cast< spot::bdd_dict * >(reinterpret_cast< std::shared_ptr< const spot::bdd_dict > * >(argp2)->get());
    }
  }
  {
    try {
      result = (bool)spot_bdd_dict_operator_SN__Se_((spot::bdd_dict const *)arg1,(spot::bdd_dict const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_bdd_dict_register_proposition__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  spot::formula arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_register_proposition" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "bdd_dict_register_proposition" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  arg3 = swig_obj[2];
  {
    try {
      result = (int)spot_bdd_dict_register_proposition__SWIG_2(arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_register_proposition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "bdd_dict_register_proposition", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_bdd_dict_register_proposition__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_bdd_dict_register_proposition__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'bdd_dict_register_proposition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::bdd_dict::register_proposition(spot::formula,void const *)\n"
    "    spot::bdd_dict::register_proposition(spot::formula,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_bdd_dict_unregister_all_my_variables__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_unregister_all_my_variables" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  arg2 = swig_obj[1];
  {
    try {
      spot_bdd_dict_unregister_all_my_variables__SWIG_1(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_unregister_all_my_variables(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "bdd_dict_unregister_all_my_variables", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_bdd_dict_unregister_all_my_variables__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_bdd_dict_unregister_all_my_variables__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'bdd_dict_unregister_all_my_variables'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::bdd_dict::unregister_all_my_variables(void const *)\n"
    "    spot::bdd_dict::unregister_all_my_variables(PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_bdd_dict_unregister_variable__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  int arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_unregister_variable" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bdd_dict_unregister_variable" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  arg3 = swig_obj[2];
  {
    try {
      spot_bdd_dict_unregister_variable__SWIG_2(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_unregister_variable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "bdd_dict_unregister_variable", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_bdd_dict_unregister_variable__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_bdd_dict_unregister_variable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'bdd_dict_unregister_variable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::bdd_dict::unregister_variable(int,void const *)\n"
    "    spot::bdd_dict::unregister_variable(int,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_bdd_dict_register_all_variables_of__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  PyObject *arg2 = (PyObject *) 0 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_register_all_variables_of" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  arg2 = swig_obj[1];
  arg3 = swig_obj[2];
  {
    try {
      spot_bdd_dict_register_all_variables_of__SWIG_4(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_register_all_variables_of(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "bdd_dict_register_all_variables_of", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_bdd_dict_register_all_variables_of__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_bdd_dict_register_all_variables_of__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'bdd_dict_register_all_variables_of'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::bdd_dict::register_all_variables_of(void const *,void const *)\n"
    "    spot::bdd_dict::register_all_variables_of(PyObject *,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_bdd_dict_register_anonymous_variables__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict *arg1 = (spot::bdd_dict *) 0 ;
  int arg2 ;
  PyObject *arg3 = (PyObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::bdd_dict > tempshared1 ;
  std::shared_ptr< spot::bdd_dict > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_dict_register_anonymous_variables" "', argument " "1"" of type '" "spot::bdd_dict *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::bdd_dict > * >(argp1);
      arg1 = const_cast< spot::bdd_dict * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bdd_dict_register_anonymous_variables" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  arg3 = swig_obj[2];
  {
    try {
      result = (int)spot_bdd_dict_register_anonymous_variables__SWIG_2(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_dict_register_anonymous_variables(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "bdd_dict_register_anonymous_variables", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_bdd_dict_register_anonymous_variables__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_bdd_dict_register_anonymous_variables__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'bdd_dict_register_anonymous_variables'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::bdd_dict::register_anonymous_variables(int,void const *)\n"
    "    spot::bdd_dict::register_anonymous_variables(int,PyObject *)\n");
  return 0;
}


SWIGINTERN PyObject *bdd_dict_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *bdd_dict_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_make_bdd_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "make_bdd_dict", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::make_bdd_dict();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::bdd_dict > *smartresult = result ? new std::shared_ptr<  spot::bdd_dict >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_print_sat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_print_sat", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_print_sat" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_print_sat" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_print_sat" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_print_sat" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_print_sat" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::bdd_print_sat(*arg1,(std::shared_ptr< spot::bdd_dict > const &)*arg2,SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_format_sat(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  bdd arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_format_sat", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_format_sat" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_format_sat" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_format_sat" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::bdd_format_sat((std::shared_ptr< spot::bdd_dict > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_print_accset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_print_accset", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_print_accset" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_print_accset" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_print_accset" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_print_accset" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_print_accset" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::bdd_print_accset(*arg1,(std::shared_ptr< spot::bdd_dict > const &)*arg2,SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_format_accset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  bdd arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_format_accset", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_format_accset" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_format_accset" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_format_accset" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::bdd_format_accset((std::shared_ptr< spot::bdd_dict > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_print_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_print_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_print_set" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_print_set" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_print_set" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_print_set" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_print_set" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::bdd_print_set(*arg1,(std::shared_ptr< spot::bdd_dict > const &)*arg2,SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_format_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  bdd arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_format_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_format_set" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_format_set" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_format_set" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::bdd_format_set((std::shared_ptr< spot::bdd_dict > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_print_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_print_formula", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_print_formula" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_print_formula" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_print_formula" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_print_formula" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_print_formula" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::bdd_print_formula(*arg1,(std::shared_ptr< spot::bdd_dict > const &)*arg2,SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_format_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  bdd arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_format_formula", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_format_formula" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_format_formula" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_format_formula" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::bdd_format_formula((std::shared_ptr< spot::bdd_dict > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_enable_utf8(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "enable_utf8", 0, 0, 0)) SWIG_fail;
  {
    try {
      spot::enable_utf8();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_format_isop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  bdd arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_format_isop", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_format_isop" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_format_isop" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_format_isop" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::bdd_format_isop((std::shared_ptr< spot::bdd_dict > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_print_isop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_print_isop", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_print_isop" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_print_isop" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_print_isop" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bdd_print_isop" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_print_isop" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::bdd_print_isop(*arg1,(std::shared_ptr< spot::bdd_dict > const &)*arg2,SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_to_bdd__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  void *arg3 = (void *) 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  int res3 ;
  bdd result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "formula_to_bdd" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_to_bdd" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "formula_to_bdd" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    try {
      result = spot::formula_to_bdd(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bdd_to_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bdd arg1 ;
  spot::bdd_dict_ptr arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "bdd_to_formula", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bdd_to_formula" "', argument " "1"" of type '" "bdd""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bdd_to_formula" "', argument " "1"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bdd_to_formula" "', argument " "2"" of type '" "spot::bdd_dict_ptr const""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
  }
  {
    try {
      result = spot::bdd_to_formula(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_to_bdd__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  std::shared_ptr< spot::twa_graph > *arg3 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared3 ;
  bdd result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "formula_to_bdd" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "formula_to_bdd" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "formula_to_bdd" "', argument " "3"" of type '" "std::shared_ptr< spot::twa_graph > const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::shared_ptr< spot::twa_graph > * >(argp3);
      delete reinterpret_cast< std::shared_ptr< spot::twa_graph > * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::shared_ptr< spot::twa_graph > * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = spot::SWIGTEMPLATEDISAMBIGUATOR formula_to_bdd< spot::twa_graph >(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,(std::shared_ptr< spot::twa_graph > const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_formula_to_bdd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "formula_to_bdd", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_formula_to_bdd__SWIG_2(self, argc, argv);
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_formula_to_bdd__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'formula_to_bdd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::formula_to_bdd(spot::formula,spot::bdd_dict_ptr const &,void *)\n"
    "    spot::formula_to_bdd< spot::twa_graph >(spot::formula,spot::bdd_dict_ptr const &,std::shared_ptr< spot::twa_graph > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_iterator" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_spot_acc_cond_rs_pair_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___nonzero__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_acc_cond_rs_pair_Sg____nonzero__((std::vector< spot::acc_cond::rs_pair > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___bool__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_acc_cond_rs_pair_Sg____bool__((std::vector< spot::acc_cond::rs_pair > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::rs_pair >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___len__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = std_vector_Sl_spot_acc_cond_rs_pair_Sg____len__((std::vector< spot::acc_cond::rs_pair > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg2 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_rs_pair___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___getslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair___getslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_rs_pair___getslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *)std_vector_Sl_spot_acc_cond_rs_pair_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg2 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___setslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair___setslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_rs_pair___setslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_rs_pair_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg2 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg3 ;
  std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___setslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair___setslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_rs_pair___setslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val3);
  {
    std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *ptr = (std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_rs_pair___setslice__" "', argument " "4"" of type '" "std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_rs_pair___setslice__" "', argument " "4"" of type '" "std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_rs_pair_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_rs_pair___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vector_rs_pair___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vector_rs_pair___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_rs_pair___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::rs_pair >::__setslice__(std::vector< spot::acc_cond::rs_pair >::difference_type,std::vector< spot::acc_cond::rs_pair >::difference_type)\n"
    "    std::vector< spot::acc_cond::rs_pair >::__setslice__(std::vector< spot::acc_cond::rs_pair >::difference_type,std::vector< spot::acc_cond::rs_pair >::difference_type,std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg2 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_rs_pair___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___delslice__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair___delslice__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_rs_pair___delslice__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_rs_pair_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___delitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair___delitem__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_rs_pair_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___getitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_rs_pair___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *)std_vector_Sl_spot_acc_cond_rs_pair_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___setitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_rs_pair___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *ptr = (std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_rs_pair___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_rs_pair___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_rs_pair_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___setitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_rs_pair___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_rs_pair_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___delitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_rs_pair___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_rs_pair_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_rs_pair___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vector_rs_pair___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vector_rs_pair___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_rs_pair___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::rs_pair >::__delitem__(std::vector< spot::acc_cond::rs_pair >::difference_type)\n"
    "    std::vector< spot::acc_cond::rs_pair >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< spot::acc_cond::rs_pair >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___getitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair___getitem__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< spot::acc_cond::rs_pair >::value_type *) &std_vector_Sl_spot_acc_cond_rs_pair_Sg____getitem____SWIG_1((std::vector< spot::acc_cond::rs_pair > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::acc_cond::rs_pair >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_rs_pair___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vector_rs_pair___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vector_rs_pair___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_rs_pair___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::rs_pair >::__getitem__(PySliceObject *)\n"
    "    std::vector< spot::acc_cond::rs_pair >::__getitem__(std::vector< spot::acc_cond::rs_pair >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::difference_type arg2 ;
  std::vector< spot::acc_cond::rs_pair >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair___setitem__" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair___setitem__" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_rs_pair___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_rs_pair___setitem__" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_spot_acc_cond_rs_pair_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(spot::acc_cond::rs_pair const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_rs_pair___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vector_rs_pair___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vector_rs_pair___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vector_rs_pair___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_rs_pair___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::rs_pair >::__setitem__(PySliceObject *,std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > const &)\n"
    "    std::vector< spot::acc_cond::rs_pair >::__setitem__(PySliceObject *)\n"
    "    std::vector< spot::acc_cond::rs_pair >::__setitem__(std::vector< spot::acc_cond::rs_pair >::difference_type,std::vector< spot::acc_cond::rs_pair >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::acc_cond::rs_pair > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_pop" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_spot_acc_cond_rs_pair_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::acc_cond::rs_pair >::value_type(result)), SWIGTYPE_p_spot__acc_cond__rs_pair, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_rs_pair_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_append" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vector_rs_pair_append" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_rs_pair_append" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_spot_acc_cond_rs_pair_Sg__append(arg1,(spot::acc_cond::rs_pair const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vector_rs_pair__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< spot::acc_cond::rs_pair > *)new std::vector< spot::acc_cond::rs_pair >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vector_rs_pair__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< spot::acc_cond::rs_pair > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *ptr = (std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_rs_pair" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vector_rs_pair" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< spot::acc_cond::rs_pair > *)new std::vector< spot::acc_cond::rs_pair >((std::vector< spot::acc_cond::rs_pair > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_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_vector_rs_pair_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_empty" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = (bool)((std::vector< spot::acc_cond::rs_pair > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::rs_pair >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_size" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = ((std::vector< spot::acc_cond::rs_pair > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_rs_pair_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_swap" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vector_rs_pair_swap" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_rs_pair_swap" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::rs_pair >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_begin" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::rs_pair >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::rs_pair >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_end" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::rs_pair >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::rs_pair >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_rbegin" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::rs_pair >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::rs_pair >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_rend" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::rs_pair >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_clear" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< spot::acc_cond::rs_pair > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_get_allocator" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = ((std::vector< spot::acc_cond::rs_pair > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::acc_cond::rs_pair >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_spot__acc_cond__rs_pair_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vector_rs_pair__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< spot::acc_cond::rs_pair > *result = 0 ;
  
  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_vector_rs_pair" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair >::size_type""'");
  } 
  arg1 = static_cast< std::vector< spot::acc_cond::rs_pair >::size_type >(val1);
  {
    try {
      result = (std::vector< spot::acc_cond::rs_pair > *)new std::vector< spot::acc_cond::rs_pair >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_pop_back" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_resize" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair_resize" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< spot::acc_cond::rs_pair >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_erase" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(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 '" "vector_rs_pair_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond::rs_pair >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond::rs_pair >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_rs_pair_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_acc_cond_rs_pair_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::rs_pair >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::iterator arg2 ;
  std::vector< spot::acc_cond::rs_pair >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< spot::acc_cond::rs_pair >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_erase" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(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 '" "vector_rs_pair_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond::rs_pair >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond::rs_pair >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_rs_pair_erase" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::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 '" "vector_rs_pair_erase" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond::rs_pair >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond::rs_pair >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_rs_pair_erase" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_acc_cond_rs_pair_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::rs_pair >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_rs_pair_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vector_rs_pair_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vector_rs_pair_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_rs_pair_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::rs_pair >::erase(std::vector< spot::acc_cond::rs_pair >::iterator)\n"
    "    std::vector< spot::acc_cond::rs_pair >::erase(std::vector< spot::acc_cond::rs_pair >::iterator,std::vector< spot::acc_cond::rs_pair >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_vector_rs_pair__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair >::size_type arg1 ;
  std::vector< spot::acc_cond::rs_pair >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< spot::acc_cond::rs_pair > *result = 0 ;
  
  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_vector_rs_pair" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair >::size_type""'");
  } 
  arg1 = static_cast< std::vector< spot::acc_cond::rs_pair >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vector_rs_pair" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vector_rs_pair" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair >::value_type * >(argp2);
  {
    try {
      result = (std::vector< spot::acc_cond::rs_pair > *)new std::vector< spot::acc_cond::rs_pair >(arg1,(std::vector< spot::acc_cond::rs_pair >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vector_rs_pair(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vector_rs_pair", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vector_rs_pair__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vector_rs_pair__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vector_rs_pair__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vector_rs_pair__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vector_rs_pair'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::rs_pair >::vector()\n"
    "    std::vector< spot::acc_cond::rs_pair >::vector(std::vector< spot::acc_cond::rs_pair > const &)\n"
    "    std::vector< spot::acc_cond::rs_pair >::vector(std::vector< spot::acc_cond::rs_pair >::size_type)\n"
    "    std::vector< spot::acc_cond::rs_pair >::vector(std::vector< spot::acc_cond::rs_pair >::size_type,std::vector< spot::acc_cond::rs_pair >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_rs_pair_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_push_back" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vector_rs_pair_push_back" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_rs_pair_push_back" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< spot::acc_cond::rs_pair >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::rs_pair >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_front" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = (std::vector< spot::acc_cond::rs_pair >::value_type *) &((std::vector< spot::acc_cond::rs_pair > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::acc_cond::rs_pair >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::rs_pair >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_back" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = (std::vector< spot::acc_cond::rs_pair >::value_type *) &((std::vector< spot::acc_cond::rs_pair > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::acc_cond::rs_pair >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::size_type arg2 ;
  std::vector< spot::acc_cond::rs_pair >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_rs_pair_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_assign" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair_assign" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_rs_pair_assign" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_rs_pair_assign" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< spot::acc_cond::rs_pair >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::size_type arg2 ;
  std::vector< spot::acc_cond::rs_pair >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_resize" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair_resize" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_rs_pair_resize" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_rs_pair_resize" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< spot::acc_cond::rs_pair >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_rs_pair_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vector_rs_pair_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vector_rs_pair_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_rs_pair_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::rs_pair >::resize(std::vector< spot::acc_cond::rs_pair >::size_type)\n"
    "    std::vector< spot::acc_cond::rs_pair >::resize(std::vector< spot::acc_cond::rs_pair >::size_type,std::vector< spot::acc_cond::rs_pair >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::iterator arg2 ;
  std::vector< spot::acc_cond::rs_pair >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< spot::acc_cond::rs_pair >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_insert" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(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 '" "vector_rs_pair_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond::rs_pair >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond::rs_pair >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_rs_pair_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_rs_pair_insert" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_rs_pair_insert" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_spot_acc_cond_rs_pair_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(spot::acc_cond::rs_pair const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::acc_cond::rs_pair >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::iterator arg2 ;
  std::vector< spot::acc_cond::rs_pair >::size_type arg3 ;
  std::vector< spot::acc_cond::rs_pair >::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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_insert" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(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 '" "vector_rs_pair_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::acc_cond::rs_pair >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::acc_cond::rs_pair >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_rs_pair_insert" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_rs_pair_insert" "', argument " "3"" of type '" "std::vector< spot::acc_cond::rs_pair >::size_type""'");
  } 
  arg3 = static_cast< std::vector< spot::acc_cond::rs_pair >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_rs_pair_insert" "', argument " "4"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_rs_pair_insert" "', argument " "4"" of type '" "std::vector< spot::acc_cond::rs_pair >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_spot_acc_cond_rs_pair_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(spot::acc_cond::rs_pair const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_rs_pair_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vector_rs_pair_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vector_rs_pair_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_rs_pair_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::acc_cond::rs_pair >::insert(std::vector< spot::acc_cond::rs_pair >::iterator,std::vector< spot::acc_cond::rs_pair >::value_type const &)\n"
    "    std::vector< spot::acc_cond::rs_pair >::insert(std::vector< spot::acc_cond::rs_pair >::iterator,std::vector< spot::acc_cond::rs_pair >::size_type,std::vector< spot::acc_cond::rs_pair >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  std::vector< spot::acc_cond::rs_pair >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_rs_pair_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_reserve" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_rs_pair_reserve" "', argument " "2"" of type '" "std::vector< spot::acc_cond::rs_pair >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::acc_cond::rs_pair >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_rs_pair_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::rs_pair >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_rs_pair_capacity" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      result = ((std::vector< spot::acc_cond::rs_pair > const *)arg1)->capacity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vector_rs_pair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::acc_cond::rs_pair > *arg1 = (std::vector< spot::acc_cond::rs_pair > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vector_rs_pair" "', argument " "1"" of type '" "std::vector< spot::acc_cond::rs_pair > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::acc_cond::rs_pair > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vector_rs_pair_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vector_rs_pair_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_acc_cond_has_parity_prefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond *arg2 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_has_parity_prefix", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_has_parity_prefix" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_has_parity_prefix" "', argument " "2"" of type '" "spot::acc_cond &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_has_parity_prefix" "', argument " "2"" of type '" "spot::acc_cond &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "acc_cond_has_parity_prefix" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_has_parity_prefix" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp3);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->has_parity_prefix(*arg2,*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acc_cond__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::acc_cond *result = 0 ;
  
  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 '" "new_acc_cond" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_acc_cond" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_acc_cond" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = (spot::acc_cond *)new spot::acc_cond(arg1,(spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 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_acc_cond__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  spot::acc_cond *result = 0 ;
  
  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 '" "new_acc_cond" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = (spot::acc_cond *)new spot::acc_cond(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acc_cond__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::acc_cond *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::acc_cond *)new spot::acc_cond();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acc_cond__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::acc_cond *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_acc_cond" "', argument " "1"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_acc_cond" "', argument " "1"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = (spot::acc_cond *)new spot::acc_cond((spot::acc_cond::acc_code const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 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_acc_cond__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::acc_cond *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_acc_cond" "', argument " "1"" of type '" "spot::acc_cond const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_acc_cond" "', argument " "1"" of type '" "spot::acc_cond const &""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (spot::acc_cond *)new spot::acc_cond((spot::acc_cond const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acc_cond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_acc_cond", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_acc_cond__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_acc_cond__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_acc_cond__SWIG_4(self, argc, argv);
  }
check_3:
  
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_new_acc_cond__SWIG_1(self, argc, argv);
  }
check_4:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_acc_cond__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_acc_cond__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_acc_cond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::acc_cond(unsigned int,spot::acc_cond::acc_code const &)\n"
    "    spot::acc_cond::acc_cond(unsigned int)\n"
    "    spot::acc_cond::acc_cond()\n"
    "    spot::acc_cond::acc_cond(spot::acc_cond::acc_code const &)\n"
    "    spot::acc_cond::acc_cond(spot::acc_cond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_acc_cond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_acc_cond" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_set_acceptance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_set_acceptance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_set_acceptance" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_set_acceptance" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_set_acceptance" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      (arg1)->set_acceptance((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_get_acceptance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_get_acceptance" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (spot::acc_cond::acc_code *) &((spot::acc_cond const *)arg1)->get_acceptance();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_get_acceptance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_get_acceptance" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (spot::acc_cond::acc_code *) &(arg1)->get_acceptance();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_get_acceptance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_cond_get_acceptance", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_cond_get_acceptance__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_cond_get_acceptance__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_cond_get_acceptance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::get_acceptance() const\n"
    "    spot::acc_cond::get_acceptance()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_cond___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond___eq__" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond___eq__" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond___eq__" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond * >(argp2);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->operator ==((spot::acc_cond const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_cond___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond___ne__" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond___ne__" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond___ne__" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond * >(argp2);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->operator !=((spot::acc_cond const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_cond_uses_fin_acceptance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_uses_fin_acceptance" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->uses_fin_acceptance();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_t" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_t();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_all" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_all();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_f" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_f();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_none(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_none" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_none();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_buchi" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_buchi();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_co_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_co_buchi" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_co_buchi();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_set_generalized_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_set_generalized_buchi" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      (arg1)->set_generalized_buchi();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_set_generalized_co_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_set_generalized_co_buchi" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      (arg1)->set_generalized_co_buchi();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_generalized_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_generalized_buchi" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_generalized_buchi();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_generalized_co_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_generalized_co_buchi" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_generalized_co_buchi();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_rabin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_rabin" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (int)((spot::acc_cond const *)arg1)->is_rabin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_streett(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_streett" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (int)((spot::acc_cond const *)arg1)->is_streett();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_streett_like(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  bool result;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_streett_like" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_streett_like(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, swig::from((*arg2)));
  } 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_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_rabin_like(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  bool result;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_rabin_like" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_rabin_like(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, swig::from((*arg2)));
  } 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_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_generalized_rabin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  bool result;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_generalized_rabin" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_generalized_rabin(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, swig::from((*arg2)));
  } 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_unsigned_int_std__allocatorT_unsigned_int_t_t, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_generalized_streett(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  bool result;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_generalized_streett" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_generalized_streett(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, swig::from((*arg2)));
  } 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_unsigned_int_std__allocatorT_unsigned_int_t_t, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_parity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  bool *arg2 = 0 ;
  bool *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool temp2 ;
  int res2 = SWIG_TMPOBJ ;
  bool temp3 ;
  int res3 = SWIG_TMPOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  bool result;
  
  arg2 = &temp2;
  arg3 = &temp3;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_parity" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  ecode4 = SWIG_AsVal_bool(swig_obj[1], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "acc_cond_is_parity" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_parity(*arg2,*arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_bool((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_bool, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_bool((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_bool, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_parity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  bool *arg2 = 0 ;
  bool *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool temp2 ;
  int res2 = SWIG_TMPOBJ ;
  bool temp3 ;
  int res3 = SWIG_TMPOBJ ;
  bool result;
  
  arg2 = &temp2;
  arg3 = &temp3;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_parity" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_parity(*arg2,*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_bool((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_bool, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_bool((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_bool, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_parity_max_equiv(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_is_parity_max_equiv", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_parity_max_equiv" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_is_parity_max_equiv" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_is_parity_max_equiv" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "acc_cond_is_parity_max_equiv" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_parity_max_equiv(*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_parity__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_is_parity" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->is_parity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_is_parity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_cond_is_parity", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_cond_is_parity__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_cond_is_parity__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_acc_cond_is_parity__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_cond_is_parity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::is_parity(bool &,bool &,bool) const\n"
    "    spot::acc_cond::is_parity(bool &,bool &) const\n"
    "    spot::acc_cond::is_parity() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_cond_unit_propagation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_unit_propagation" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (arg1)->unit_propagation();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond(result)), SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_unsat_mark(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::pair< bool,spot::acc_cond::mark_t > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_unsat_mark" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->unsat_mark();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::pair< bool,spot::acc_cond::mark_t >(result)), SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_sat_mark(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::pair< bool,spot::acc_cond::mark_t > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_sat_mark" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->sat_mark();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::pair< bool,spot::acc_cond::mark_t >(result)), SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_inf__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_inf" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_inf" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = spot::acc_cond::inf(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_inf__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::initializer_list< unsigned int > > arg1 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  
  {
    try {
      result = spot::acc_cond::inf(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_inf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_cond_inf", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_acc_cond_inf__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_2;
    return _wrap_acc_cond_inf__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_cond_inf__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_cond_inf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::inf(spot::acc_cond::mark_t)\n"
    "    spot::acc_cond::inf(std::initializer_list< unsigned int >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_cond_inf_neg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_inf_neg" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_inf_neg" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = spot::acc_cond::inf_neg(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_inf_neg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::initializer_list< unsigned int > > arg1 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  
  {
    try {
      result = spot::acc_cond::inf_neg(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_inf_neg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_cond_inf_neg", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_acc_cond_inf_neg__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_2;
    return _wrap_acc_cond_inf_neg__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_cond_inf_neg__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_cond_inf_neg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::inf_neg(spot::acc_cond::mark_t)\n"
    "    spot::acc_cond::inf_neg(std::initializer_list< unsigned int >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_cond_fin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_fin" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_fin" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = spot::acc_cond::fin(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_fin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::initializer_list< unsigned int > > arg1 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  
  {
    try {
      result = spot::acc_cond::fin(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_fin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_cond_fin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_acc_cond_fin__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_2;
    return _wrap_acc_cond_fin__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_cond_fin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_cond_fin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::fin(spot::acc_cond::mark_t)\n"
    "    spot::acc_cond::fin(std::initializer_list< unsigned int >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_cond_fin_neg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_fin_neg" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_fin_neg" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = spot::acc_cond::fin_neg(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_fin_neg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::initializer_list< unsigned int > > arg1 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  
  {
    try {
      result = spot::acc_cond::fin_neg(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_fin_neg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_cond_fin_neg", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_acc_cond_fin_neg__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_2;
    return _wrap_acc_cond_fin_neg__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_cond_fin_neg__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_cond_fin_neg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::fin_neg(spot::acc_cond::mark_t)\n"
    "    spot::acc_cond::fin_neg(std::initializer_list< unsigned int >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_cond_add_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_add_sets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_add_sets" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acc_cond_add_sets" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)(arg1)->add_sets(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_add_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_add_set" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (unsigned int)(arg1)->add_set();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_mark(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_mark", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_mark" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acc_cond_mark" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->mark(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_comp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::mark_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_comp", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_comp" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_comp" "', argument " "2"" of type '" "spot::acc_cond::mark_t const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_comp" "', argument " "2"" of type '" "spot::acc_cond::mark_t const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->comp((spot::acc_cond::mark_t const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_all_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_all_sets" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->all_sets();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_apply_permutation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_apply_permutation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_apply_permutation" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(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 '" "acc_cond_apply_permutation" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (arg1)->apply_permutation(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond(result)), SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_apply_permutation_aux(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_apply_permutation_aux", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_apply_permutation_aux" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(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 '" "acc_cond_apply_permutation_aux" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (arg1)->apply_permutation_aux(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_accepting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_accepting", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_accepting" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_accepting" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_accepting" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->accepting(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_inf_satisfiable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_inf_satisfiable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_inf_satisfiable" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_inf_satisfiable" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_inf_satisfiable" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond const *)arg1)->inf_satisfiable(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_maybe_accepting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  spot::acc_cond::mark_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::trival result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_maybe_accepting", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_maybe_accepting" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_maybe_accepting" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_maybe_accepting" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "acc_cond_maybe_accepting" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_maybe_accepting" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond const *)arg1)->maybe_accepting(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_accepting_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_accepting_sets", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_accepting_sets" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_accepting_sets" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_accepting_sets" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond const *)arg1)->accepting_sets(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_format__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  std::ostream *arg2 = 0 ;
  spot::acc_cond::mark_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_format" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_format" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_format" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "acc_cond_format" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_format" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (std::ostream *) &((spot::acc_cond const *)arg1)->format(*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_format__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_format" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_format" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_format" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond const *)arg1)->format(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_format(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_cond_format", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_acc_cond_format__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_acc_cond_format__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_cond_format'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::format(std::ostream &,spot::acc_cond::mark_t) const\n"
    "    spot::acc_cond::format(spot::acc_cond::mark_t) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_cond_num_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_num_sets" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (unsigned int)((spot::acc_cond const *)arg1)->num_sets();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::acc_cond result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_remove", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_remove" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_remove" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_remove" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "acc_cond_remove" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->remove(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond(result)), SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_strip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::acc_cond result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_strip", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_strip" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_strip" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_strip" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "acc_cond_strip" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->strip(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond(result)), SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_force_inf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_force_inf", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_force_inf" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_force_inf" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_force_inf" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond const *)arg1)->force_inf(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond(result)), SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_restrict_to(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_cond_restrict_to", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_restrict_to" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_restrict_to" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_cond_restrict_to" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond const *)arg1)->restrict_to(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond(result)), SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_name__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_name" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_cond_name" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->name((char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_name__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_name" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->name();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_name(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_cond_name", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_cond_name__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_acc_cond_name__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_cond_name'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::name(char const *) const\n"
    "    spot::acc_cond::name() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_cond_fin_unit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_fin_unit" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->fin_unit();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_inf_unit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_inf_unit" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->inf_unit();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_fin_one(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_fin_one" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (int)((spot::acc_cond const *)arg1)->fin_one();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_fin_one_extract(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::pair< int,spot::acc_cond > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_fin_one_extract" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->fin_one_extract();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< int,spot::acc_cond > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_fin_unit_one_split(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::tuple< int,spot::acc_cond,spot::acc_cond > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_fin_unit_one_split" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->fin_unit_one_split();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  
  {
    auto& v = static_cast<const std::tuple<int, spot::acc_cond, spot::acc_cond>>(result);
    resultobj = PyTuple_Pack(3,
      swig::from(std::get<0>(v)),
      swig::from(std::get<1>(v)),
      swig::from(std::get<2>(v)));
  }
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_top_disjuncts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_top_disjuncts" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->top_disjuncts();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond_top_conjuncts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond_top_conjuncts" "', argument " "1"" of type '" "spot::acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = ((spot::acc_cond const *)arg1)->top_conjuncts();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond___repr__" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = spot_acc_cond___repr__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_cond___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = (spot::acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_cond___str__" "', argument " "1"" of type '" "spot::acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = spot_acc_cond___str__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *acc_cond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__acc_cond, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *acc_cond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mark_t__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::acc_cond::mark_t *)new spot::acc_cond::mark_t();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_apply_permutation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t_apply_permutation", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_apply_permutation" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_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 '" "mark_t_apply_permutation" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (arg1)->apply_permutation(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_max_accsets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t_max_accsets", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)spot::acc_cond::mark_t::max_accsets();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t_all", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::acc_cond::mark_t::all();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_hash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_hash" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->hash();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___eq____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___eq__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mark_t___eq__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->operator ==(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___ne____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___ne__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mark_t___ne__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->operator !=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___eq____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___eq__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___eq__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___eq__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->operator ==(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___eq__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "mark_t___eq__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_mark_t___eq____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_mark_t___eq____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_mark_t___eq____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___ne____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___ne__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___ne__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___ne__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->operator !=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___ne__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "mark_t___ne__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_mark_t___ne____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_mark_t___ne____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_mark_t___ne____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___lt__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___lt__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___lt__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->operator <(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___le__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___le__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___le__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->operator <=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___gt__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___gt__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___gt__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->operator >(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___ge__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___ge__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___ge__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->operator >=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___nonzero__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->operator bool();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_has(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t_has", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_has" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mark_t_has" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->has(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_set" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mark_t_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      (arg1)->set(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t_clear", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_clear" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mark_t_clear" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      (arg1)->clear(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___iand__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___iand__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___iand__" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___iand__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___iand__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::acc_cond::mark_t *) &(arg1)->operator &=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___ior__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___ior__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___ior__" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___ior__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___ior__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::acc_cond::mark_t *) &(arg1)->operator |=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___isub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___isub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___isub__" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___isub__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___isub__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::acc_cond::mark_t *) &(arg1)->operator -=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___ixor__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___ixor__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___ixor__" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___ixor__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___ixor__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::acc_cond::mark_t *) &(arg1)->operator ^=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___and__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___and__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___and__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___and__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___and__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->operator &(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___or__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___or__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___or__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___or__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___or__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->operator |(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___sub__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___sub__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___sub__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___sub__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___sub__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->operator -(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___invert__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___invert__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->operator ~();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___xor__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___xor__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___xor__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t___xor__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t___xor__" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->operator ^(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_t___lshift__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___lshift__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___lshift__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mark_t___lshift__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->operator <<(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___ilshift__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___ilshift__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___ilshift__" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mark_t___ilshift__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::acc_cond::mark_t *) &(arg1)->operator <<=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___rshift__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___rshift__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___rshift__" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mark_t___rshift__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->operator >>(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___irshift__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t___irshift__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___irshift__" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mark_t___irshift__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::acc_cond::mark_t *) &(arg1)->operator >>=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_strip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t_strip", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_strip" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t_strip" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t_strip" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->strip(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_subset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t_subset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_subset" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t_subset" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t_subset" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->subset(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_proper_subset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t_proper_subset", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_proper_subset" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_t_proper_subset" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_t_proper_subset" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->proper_subset(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_count" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = (unsigned int)((spot::acc_cond::mark_t const *)arg1)->count();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_max_set" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = (unsigned int)((spot::acc_cond::mark_t const *)arg1)->max_set();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_min_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_min_set" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = (unsigned int)((spot::acc_cond::mark_t const *)arg1)->min_set();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_lowest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_lowest" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->lowest();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_is_singleton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_is_singleton" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->is_singleton();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_has_many(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_has_many" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond::mark_t const *)arg1)->has_many();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_remove_some(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_t_remove_some", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_remove_some" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mark_t_remove_some" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::acc_cond::mark_t *) &(arg1)->remove_some(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::mark_container > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_sets" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->sets();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::mark_container(result)), SWIGTYPE_p_spot__internal__mark_container, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t_as_string(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t_as_string" "', argument " "1"" of type '" "spot::acc_cond::mark_t const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = ((spot::acc_cond::mark_t const *)arg1)->as_string();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_mark_t__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::acc_cond::mark_t *result = 0 ;
  
  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_mark_t" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mark_t" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (spot::acc_cond::mark_t *)new_spot_acc_cond_mark_t__SWIG_1((std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_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_mark_t(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_mark_t", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_mark_t__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_mark_t__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mark_t'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::mark_t::mark_t()\n"
    "    spot::acc_cond::mark_t::mark_t(std::vector< unsigned int,std::allocator< unsigned int > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_mark_t___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___repr__" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = spot_acc_cond_mark_t___repr__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_t___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_t___str__" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      result = spot_acc_cond_mark_t___str__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_mark_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t *arg1 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mark_t" "', argument " "1"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *mark_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mark_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_acc_code_unit_propagation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_unit_propagation" "', argument " "1"" of type '" "spot::acc_cond::acc_code *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = (arg1)->unit_propagation();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_has_parity_prefix(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond *arg2 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_has_parity_prefix", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_has_parity_prefix" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_has_parity_prefix" "', argument " "2"" of type '" "spot::acc_cond &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_has_parity_prefix" "', argument " "2"" of type '" "spot::acc_cond &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "acc_code_has_parity_prefix" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_has_parity_prefix" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp3);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->has_parity_prefix(*arg2,*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_is_parity_max_equiv(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  unsigned int arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_is_parity_max_equiv", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_is_parity_max_equiv" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_is_parity_max_equiv" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_is_parity_max_equiv" "', 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 '" "acc_code_is_parity_max_equiv" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "acc_code_is_parity_max_equiv" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->is_parity_max_equiv(*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___eq__" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code___eq__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code___eq__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->operator ==((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_code___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___lt__" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code___lt__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code___lt__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->operator <((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_code___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___gt__" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code___gt__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code___gt__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->operator >((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_code___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___le__" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code___le__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code___le__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->operator <=((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_code___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___ge__" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code___ge__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code___ge__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->operator >=((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_code___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___ne__" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code___ne__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code___ne__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->operator !=((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_code_is_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_is_t" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->is_t();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_is_f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_is_f" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->is_f();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_f(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_f", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::acc_cond::acc_code::f();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_t", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::acc_cond::acc_code::t();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_fin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_fin" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_fin" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = spot::acc_cond::acc_code::fin(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_fin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::initializer_list< unsigned int > > arg1 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  
  {
    try {
      result = spot::acc_cond::acc_code::fin(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_fin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_code_fin", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_acc_code_fin__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_2;
    return _wrap_acc_code_fin__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_code_fin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_code_fin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::acc_code::fin(spot::acc_cond::mark_t)\n"
    "    spot::acc_cond::acc_code::fin(std::initializer_list< unsigned int >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_code_fin_neg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_fin_neg" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_fin_neg" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = spot::acc_cond::acc_code::fin_neg(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_fin_neg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::initializer_list< unsigned int > > arg1 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  
  {
    try {
      result = spot::acc_cond::acc_code::fin_neg(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_fin_neg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_code_fin_neg", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_acc_code_fin_neg__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_2;
    return _wrap_acc_code_fin_neg__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_code_fin_neg__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_code_fin_neg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::acc_code::fin_neg(spot::acc_cond::mark_t)\n"
    "    spot::acc_cond::acc_code::fin_neg(std::initializer_list< unsigned int >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_code_inf__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_inf" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_inf" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = spot::acc_cond::acc_code::inf(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_inf__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::initializer_list< unsigned int > > arg1 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  
  {
    try {
      result = spot::acc_cond::acc_code::inf(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_inf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_code_inf", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_acc_code_inf__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_2;
    return _wrap_acc_code_inf__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_code_inf__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_code_inf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::acc_code::inf(spot::acc_cond::mark_t)\n"
    "    spot::acc_cond::acc_code::inf(std::initializer_list< unsigned int >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_code_inf_neg__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_inf_neg" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_inf_neg" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = spot::acc_cond::acc_code::inf_neg(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_inf_neg__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::initializer_list< unsigned int > > arg1 ;
  spot::acc_cond::acc_code result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  
  {
    try {
      result = spot::acc_cond::acc_code::inf_neg(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_inf_neg(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_code_inf_neg", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_acc_code_inf_neg__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_2;
    return _wrap_acc_code_inf_neg__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_code_inf_neg__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_code_inf_neg'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::acc_code::inf_neg(spot::acc_cond::mark_t)\n"
    "    spot::acc_cond::acc_code::inf_neg(std::initializer_list< unsigned int >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_code_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_buchi", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::acc_cond::acc_code::buchi();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_cobuchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_cobuchi", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::acc_cond::acc_code::cobuchi();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_generalized_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_generalized_buchi" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = spot::acc_cond::acc_code::generalized_buchi(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_generalized_co_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_generalized_co_buchi" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = spot::acc_cond::acc_code::generalized_co_buchi(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_rabin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_rabin" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = spot::acc_cond::acc_code::rabin(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_streett(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_streett" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = spot::acc_cond::acc_code::streett(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_parity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  unsigned int arg3 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_parity", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_parity" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acc_code_parity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "acc_code_parity" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = spot::acc_cond::acc_code::parity(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_parity_max(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  unsigned int arg2 ;
  bool val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_parity_max", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_parity_max" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acc_code_parity_max" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = spot::acc_cond::acc_code::parity_max(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_parity_max_odd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_parity_max_odd" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = spot::acc_cond::acc_code::parity_max_odd(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_parity_max_even(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_parity_max_even" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = spot::acc_cond::acc_code::parity_max_even(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_parity_min(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool arg1 ;
  unsigned int arg2 ;
  bool val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_parity_min", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_parity_min" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acc_code_parity_min" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = spot::acc_cond::acc_code::parity_min(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_parity_min_odd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_parity_min_odd" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = spot::acc_cond::acc_code::parity_min_odd(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_parity_min_even(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "acc_code_parity_min_even" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = spot::acc_cond::acc_code::parity_min_even(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_random__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  double arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  spot::acc_cond::acc_code result;
  
  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 '" "acc_code_random" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acc_code_random" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = spot::acc_cond::acc_code::random(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_random__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  spot::acc_cond::acc_code result;
  
  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 '" "acc_code_random" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = spot::acc_cond::acc_code::random(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_random(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_code_random", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_acc_code_random__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_acc_code_random__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_code_random'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::acc_code::random(unsigned int,double)\n"
    "    spot::acc_cond::acc_code::random(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_code___iand__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::acc_code *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___iand__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___iand__" "', argument " "1"" of type '" "spot::acc_cond::acc_code *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code___iand__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code___iand__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = (spot::acc_cond::acc_code *) &(arg1)->operator &=((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code___and__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___and__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___and__" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code___and__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code___and__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->operator &((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_code___ior__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::acc_code *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___ior__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___ior__" "', argument " "1"" of type '" "spot::acc_cond::acc_code *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code___ior__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code___ior__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = (spot::acc_cond::acc_code *) &(arg1)->operator |=((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code___or__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::acc_code *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___or__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___or__" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code___or__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code___or__" "', argument " "2"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::acc_code * >(argp2);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->operator |((spot::acc_cond::acc_code const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_code___ilshift__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::acc_code *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___ilshift__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___ilshift__" "', argument " "1"" of type '" "spot::acc_cond::acc_code *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acc_code___ilshift__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::acc_cond::acc_code *) &(arg1)->operator <<=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code___lshift__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code___lshift__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___lshift__" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acc_code___lshift__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->operator <<(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_acc_code_is_dnf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_is_dnf" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->is_dnf();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_is_cnf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_is_cnf" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->is_cnf();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_to_dnf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_to_dnf" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->to_dnf();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_to_cnf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_to_cnf" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->to_cnf();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_to_bdd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  bdd *arg2 = (bdd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bdd result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_to_bdd", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_to_bdd" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_bdd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_to_bdd" "', argument " "2"" of type '" "bdd const *""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->to_bdd((bdd const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_top_disjuncts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_top_disjuncts" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->top_disjuncts();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_top_conjuncts(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_top_conjuncts" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->top_conjuncts();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_complement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_complement" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->complement();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_fin_unit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_fin_unit" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->fin_unit();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_inf_unit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_inf_unit" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->inf_unit();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_fin_one(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_fin_one" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = (int)((spot::acc_cond::acc_code const *)arg1)->fin_one();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_fin_one_extract(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::pair< int,spot::acc_cond::acc_code > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_fin_one_extract" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->fin_one_extract();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< int,spot::acc_cond::acc_code > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_fin_unit_one_split(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::tuple< int,spot::acc_cond::acc_code,spot::acc_cond::acc_code > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_fin_unit_one_split" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->fin_unit_one_split();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::tuple< int,spot::acc_cond::acc_code,spot::acc_cond::acc_code >(result)), SWIGTYPE_p_std__tupleT_int_spot__acc_cond__acc_code_spot__acc_cond__acc_code_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_missing(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SwigValueWrapper< std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_missing", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_missing" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_missing" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_missing" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "acc_code_missing" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->missing(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >(result)), SWIGTYPE_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_accepting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_accepting", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_accepting" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_accepting" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_accepting" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->accepting(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_inf_satisfiable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_inf_satisfiable", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_inf_satisfiable" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_inf_satisfiable" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_inf_satisfiable" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::acc_code const *)arg1)->inf_satisfiable(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_maybe_accepting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  spot::acc_cond::mark_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::trival result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_maybe_accepting", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_maybe_accepting" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_maybe_accepting" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_maybe_accepting" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "acc_code_maybe_accepting" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_maybe_accepting" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->maybe_accepting(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_symmetries(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_symmetries" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->symmetries();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_remove", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_remove" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_remove" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_remove" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "acc_code_remove" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->remove(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_strip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_strip", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_strip" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_strip" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_strip" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "acc_code_strip" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->strip(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_force_inf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::acc_code result;
  
  if (!SWIG_Python_UnpackTuple(args, "acc_code_force_inf", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_force_inf" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_force_inf" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_force_inf" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->force_inf(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::acc_code(result)), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_used_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_used_sets" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->used_sets();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_useless_colors_patterns(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t >,std::allocator< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_useless_colors_patterns" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->useless_colors_patterns();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t >,std::allocator< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > > >(result)), SWIGTYPE_p_std__vectorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_std__allocatorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_used_once_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_used_once_sets" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->used_once_sets();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_used_inf_fin_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_used_inf_fin_sets" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = ((spot::acc_cond::acc_code const *)arg1)->used_inf_fin_sets();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_to_html__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  std::ostream *arg2 = 0 ;
  std::function< void (std::ostream &,int) > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_to_html" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_to_html" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_to_html" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__functionT_void_fstd__ostream_R_intF_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "acc_code_to_html" "', argument " "3"" of type '" "std::function< void (std::ostream &,int) >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_to_html" "', argument " "3"" of type '" "std::function< void (std::ostream &,int) >""'");
    } else {
      std::function< void (std::ostream &,int) > * temp = reinterpret_cast< std::function< void (std::ostream &,int) > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (std::ostream *) &((spot::acc_cond::acc_code const *)arg1)->to_html(*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_to_html__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_to_html" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_to_html" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_to_html" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::acc_cond::acc_code const *)arg1)->to_html(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_to_html(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_code_to_html", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_acc_code_to_html__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_acc_code_to_html__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_code_to_html'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::acc_code::to_html(std::ostream &,std::function< void (std::ostream &,int) >) const\n"
    "    spot::acc_cond::acc_code::to_html(std::ostream &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_code_to_text__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  std::ostream *arg2 = 0 ;
  std::function< void (std::ostream &,int) > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_to_text" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_to_text" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_to_text" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__functionT_void_fstd__ostream_R_intF_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "acc_code_to_text" "', argument " "3"" of type '" "std::function< void (std::ostream &,int) >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_to_text" "', argument " "3"" of type '" "std::function< void (std::ostream &,int) >""'");
    } else {
      std::function< void (std::ostream &,int) > * temp = reinterpret_cast< std::function< void (std::ostream &,int) > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (std::ostream *) &((spot::acc_cond::acc_code const *)arg1)->to_text(*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_to_text__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_to_text" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_to_text" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_to_text" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::acc_cond::acc_code const *)arg1)->to_text(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_to_text(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_code_to_text", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_acc_code_to_text__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_acc_code_to_text__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_code_to_text'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::acc_code::to_text(std::ostream &,std::function< void (std::ostream &,int) >) const\n"
    "    spot::acc_cond::acc_code::to_text(std::ostream &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_code_to_latex__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  std::ostream *arg2 = 0 ;
  std::function< void (std::ostream &,int) > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_to_latex" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_to_latex" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_to_latex" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__functionT_void_fstd__ostream_R_intF_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "acc_code_to_latex" "', argument " "3"" of type '" "std::function< void (std::ostream &,int) >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_to_latex" "', argument " "3"" of type '" "std::function< void (std::ostream &,int) >""'");
    } else {
      std::function< void (std::ostream &,int) > * temp = reinterpret_cast< std::function< void (std::ostream &,int) > * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (std::ostream *) &((spot::acc_cond::acc_code const *)arg1)->to_latex(*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_to_latex__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code_to_latex" "', argument " "1"" of type '" "spot::acc_cond::acc_code const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acc_code_to_latex" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acc_code_to_latex" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::acc_cond::acc_code const *)arg1)->to_latex(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code_to_latex(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acc_code_to_latex", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_acc_code_to_latex__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_acc_code_to_latex__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acc_code_to_latex'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::acc_code::to_latex(std::ostream &,std::function< void (std::ostream &,int) >) const\n"
    "    spot::acc_cond::acc_code::to_latex(std::ostream &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_acc_code__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  spot::acc_cond::acc_code *result = 0 ;
  
  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 '" "new_acc_code" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (spot::acc_cond::acc_code *)new spot::acc_cond::acc_code((char const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, 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_acc_code__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::acc_cond::acc_code *)new spot::acc_cond::acc_code();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acc_code__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_word *arg1 = (spot::acc_cond::acc_word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::acc_cond::acc_code *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_word, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_acc_code" "', argument " "1"" of type '" "spot::acc_cond::acc_word const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_word * >(argp1);
  {
    try {
      result = (spot::acc_cond::acc_code *)new spot::acc_cond::acc_code((spot::acc_cond::acc_word const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acc_code(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_acc_code", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_acc_code__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_spot__acc_cond__acc_word, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_acc_code__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_acc_code__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_acc_code'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acc_cond::acc_code::acc_code(char const *)\n"
    "    spot::acc_cond::acc_code::acc_code()\n"
    "    spot::acc_cond::acc_code::acc_code(spot::acc_cond::acc_word const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acc_code___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___repr__" "', argument " "1"" of type '" "spot::acc_cond::acc_code *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = spot_acc_cond_acc_code___repr__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acc_code___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acc_code___str__" "', argument " "1"" of type '" "spot::acc_cond::acc_code *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      result = spot_acc_cond_acc_code___str__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_acc_code(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::acc_code *arg1 = (spot::acc_cond::acc_code *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_acc_code" "', argument " "1"" of type '" "spot::acc_cond::acc_code *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::acc_code * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *acc_code_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__acc_cond__acc_code, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *acc_code_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_rs_pair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::rs_pair *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_rs_pair", 2, 2, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_rs_pair" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_rs_pair" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_rs_pair" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_rs_pair" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::acc_cond::rs_pair *)new spot::acc_cond::rs_pair(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__rs_pair, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rs_pair_fin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  spot::acc_cond::mark_t *arg2 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "rs_pair_fin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair_fin_set" "', argument " "1"" of type '" "spot::acc_cond::rs_pair *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rs_pair_fin_set" "', argument " "2"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
  if (arg1) (arg1)->fin = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rs_pair_fin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair_fin_get" "', argument " "1"" of type '" "spot::acc_cond::rs_pair *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  result = (spot::acc_cond::mark_t *)& ((arg1)->fin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rs_pair_inf_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  spot::acc_cond::mark_t *arg2 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "rs_pair_inf_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair_inf_set" "', argument " "1"" of type '" "spot::acc_cond::rs_pair *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rs_pair_inf_set" "', argument " "2"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
  if (arg1) (arg1)->inf = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rs_pair_inf_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair_inf_get" "', argument " "1"" of type '" "spot::acc_cond::rs_pair *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  result = (spot::acc_cond::mark_t *)& ((arg1)->inf);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rs_pair___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  SwigValueWrapper< spot::acc_cond::rs_pair > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "rs_pair___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair___eq__" "', argument " "1"" of type '" "spot::acc_cond::rs_pair const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rs_pair___eq__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rs_pair___eq__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'");
    } else {
      spot::acc_cond::rs_pair * temp = reinterpret_cast< spot::acc_cond::rs_pair * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::rs_pair const *)arg1)->operator ==(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_rs_pair___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  SwigValueWrapper< spot::acc_cond::rs_pair > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "rs_pair___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair___ne__" "', argument " "1"" of type '" "spot::acc_cond::rs_pair const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rs_pair___ne__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rs_pair___ne__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'");
    } else {
      spot::acc_cond::rs_pair * temp = reinterpret_cast< spot::acc_cond::rs_pair * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::rs_pair const *)arg1)->operator !=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_rs_pair___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  SwigValueWrapper< spot::acc_cond::rs_pair > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "rs_pair___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair___lt__" "', argument " "1"" of type '" "spot::acc_cond::rs_pair const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rs_pair___lt__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rs_pair___lt__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'");
    } else {
      spot::acc_cond::rs_pair * temp = reinterpret_cast< spot::acc_cond::rs_pair * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::rs_pair const *)arg1)->operator <(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_rs_pair___le__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  SwigValueWrapper< spot::acc_cond::rs_pair > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "rs_pair___le__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair___le__" "', argument " "1"" of type '" "spot::acc_cond::rs_pair const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rs_pair___le__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rs_pair___le__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'");
    } else {
      spot::acc_cond::rs_pair * temp = reinterpret_cast< spot::acc_cond::rs_pair * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::rs_pair const *)arg1)->operator <=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_rs_pair___gt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  SwigValueWrapper< spot::acc_cond::rs_pair > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "rs_pair___gt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair___gt__" "', argument " "1"" of type '" "spot::acc_cond::rs_pair const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rs_pair___gt__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rs_pair___gt__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'");
    } else {
      spot::acc_cond::rs_pair * temp = reinterpret_cast< spot::acc_cond::rs_pair * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::rs_pair const *)arg1)->operator >(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_rs_pair___ge__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  SwigValueWrapper< spot::acc_cond::rs_pair > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "rs_pair___ge__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair___ge__" "', argument " "1"" of type '" "spot::acc_cond::rs_pair const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__rs_pair,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rs_pair___ge__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rs_pair___ge__" "', argument " "2"" of type '" "spot::acc_cond::rs_pair""'");
    } else {
      spot::acc_cond::rs_pair * temp = reinterpret_cast< spot::acc_cond::rs_pair * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::acc_cond::rs_pair const *)arg1)->operator >=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_rs_pair___repr__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pair___repr__" "', argument " "1"" of type '" "spot::acc_cond::rs_pair *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  {
    try {
      result = spot_acc_cond_rs_pair___repr__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_rs_pair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::rs_pair *arg1 = (spot::acc_cond::rs_pair *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acc_cond__rs_pair, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_rs_pair" "', argument " "1"" of type '" "spot::acc_cond::rs_pair *""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond::rs_pair * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *rs_pair_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__acc_cond__rs_pair, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *rs_pair_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_rs_pairs_view__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::rs_pairs_view::rs_pairs *arg1 = 0 ;
  spot::acc_cond::mark_t *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::rs_pairs_view *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *ptr = (std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_rs_pairs_view" "', argument " "1"" of type '" "spot::rs_pairs_view::rs_pairs const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_rs_pairs_view" "', argument " "1"" of type '" "spot::rs_pairs_view::rs_pairs const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_rs_pairs_view" "', argument " "2"" of type '" "spot::acc_cond::mark_t const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_rs_pairs_view" "', argument " "2"" of type '" "spot::acc_cond::mark_t const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
  {
    try {
      result = (spot::rs_pairs_view *)new spot::rs_pairs_view((spot::rs_pairs_view::rs_pairs const &)*arg1,(spot::acc_cond::mark_t const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__rs_pairs_view, SWIG_POINTER_NEW |  0 );
  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_new_rs_pairs_view__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::rs_pairs_view::rs_pairs *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::rs_pairs_view *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *ptr = (std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_rs_pairs_view" "', argument " "1"" of type '" "spot::rs_pairs_view::rs_pairs const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_rs_pairs_view" "', argument " "1"" of type '" "spot::rs_pairs_view::rs_pairs const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (spot::rs_pairs_view *)new spot::rs_pairs_view((spot::rs_pairs_view::rs_pairs const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__rs_pairs_view, 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_rs_pairs_view(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_rs_pairs_view", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_rs_pairs_view__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_rs_pairs_view__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_rs_pairs_view'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::rs_pairs_view::rs_pairs_view(spot::rs_pairs_view::rs_pairs const &,spot::acc_cond::mark_t const &)\n"
    "    spot::rs_pairs_view::rs_pairs_view(spot::rs_pairs_view::rs_pairs const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_rs_pairs_view_infs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::rs_pairs_view *arg1 = (spot::rs_pairs_view *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__rs_pairs_view, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pairs_view_infs" "', argument " "1"" of type '" "spot::rs_pairs_view const *""'"); 
  }
  arg1 = reinterpret_cast< spot::rs_pairs_view * >(argp1);
  {
    try {
      result = ((spot::rs_pairs_view const *)arg1)->infs();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rs_pairs_view_fins(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::rs_pairs_view *arg1 = (spot::rs_pairs_view *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__rs_pairs_view, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pairs_view_fins" "', argument " "1"" of type '" "spot::rs_pairs_view const *""'"); 
  }
  arg1 = reinterpret_cast< spot::rs_pairs_view * >(argp1);
  {
    try {
      result = ((spot::rs_pairs_view const *)arg1)->fins();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rs_pairs_view_fins_alone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::rs_pairs_view *arg1 = (spot::rs_pairs_view *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__rs_pairs_view, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pairs_view_fins_alone" "', argument " "1"" of type '" "spot::rs_pairs_view const *""'"); 
  }
  arg1 = reinterpret_cast< spot::rs_pairs_view * >(argp1);
  {
    try {
      result = ((spot::rs_pairs_view const *)arg1)->fins_alone();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rs_pairs_view_infs_alone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::rs_pairs_view *arg1 = (spot::rs_pairs_view *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__rs_pairs_view, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pairs_view_infs_alone" "', argument " "1"" of type '" "spot::rs_pairs_view const *""'"); 
  }
  arg1 = reinterpret_cast< spot::rs_pairs_view * >(argp1);
  {
    try {
      result = ((spot::rs_pairs_view const *)arg1)->infs_alone();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rs_pairs_view_paired_with_fin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::rs_pairs_view *arg1 = (spot::rs_pairs_view *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "rs_pairs_view_paired_with_fin", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__rs_pairs_view, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pairs_view_paired_with_fin" "', argument " "1"" of type '" "spot::rs_pairs_view const *""'"); 
  }
  arg1 = reinterpret_cast< spot::rs_pairs_view * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rs_pairs_view_paired_with_fin" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::rs_pairs_view const *)arg1)->paired_with_fin(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rs_pairs_view_pairs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::rs_pairs_view *arg1 = (spot::rs_pairs_view *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::rs_pairs_view::rs_pairs *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__rs_pairs_view, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rs_pairs_view_pairs" "', argument " "1"" of type '" "spot::rs_pairs_view const *""'"); 
  }
  arg1 = reinterpret_cast< spot::rs_pairs_view * >(argp1);
  {
    try {
      result = (spot::rs_pairs_view::rs_pairs *) &((spot::rs_pairs_view const *)arg1)->pairs();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_rs_pairs_view(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::rs_pairs_view *arg1 = (spot::rs_pairs_view *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__rs_pairs_view, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_rs_pairs_view" "', argument " "1"" of type '" "spot::rs_pairs_view *""'"); 
  }
  arg1 = reinterpret_cast< spot::rs_pairs_view * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *rs_pairs_view_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__rs_pairs_view, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *rs_pairs_view_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::acc_cond *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond * >(argp2);
  {
    try {
      result = (std::ostream *) &spot::operator <<(*arg1,(spot::acc_cond const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new_mark_iterator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::internal::mark_iterator *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::internal::mark_iterator *)new spot::internal::mark_iterator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__mark_iterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_mark_iterator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::internal::mark_iterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mark_iterator" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mark_iterator" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = (spot::internal::mark_iterator *)new spot::internal::mark_iterator(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__mark_iterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_mark_iterator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_mark_iterator", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_mark_iterator__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_mark_iterator__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_mark_iterator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::internal::mark_iterator::mark_iterator()\n"
    "    spot::internal::mark_iterator::mark_iterator(spot::acc_cond::mark_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_mark_iterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::mark_iterator *arg1 = (spot::internal::mark_iterator *) 0 ;
  spot::internal::mark_iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_iterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__mark_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_iterator___eq__" "', argument " "1"" of type '" "spot::internal::mark_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::mark_iterator * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__mark_iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_iterator___eq__" "', argument " "2"" of type '" "spot::internal::mark_iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_iterator___eq__" "', argument " "2"" of type '" "spot::internal::mark_iterator""'");
    } else {
      spot::internal::mark_iterator * temp = reinterpret_cast< spot::internal::mark_iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::internal::mark_iterator const *)arg1)->operator ==(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_iterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::mark_iterator *arg1 = (spot::internal::mark_iterator *) 0 ;
  spot::internal::mark_iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "mark_iterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__mark_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_iterator___ne__" "', argument " "1"" of type '" "spot::internal::mark_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::mark_iterator * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__mark_iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mark_iterator___ne__" "', argument " "2"" of type '" "spot::internal::mark_iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mark_iterator___ne__" "', argument " "2"" of type '" "spot::internal::mark_iterator""'");
    } else {
      spot::internal::mark_iterator * temp = reinterpret_cast< spot::internal::mark_iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::internal::mark_iterator const *)arg1)->operator !=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_mark_iterator___ref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::mark_iterator *arg1 = (spot::internal::mark_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::internal::mark_iterator::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__mark_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_iterator___ref__" "', argument " "1"" of type '" "spot::internal::mark_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::mark_iterator * >(argp1);
  {
    try {
      result = (spot::internal::mark_iterator::value_type)((spot::internal::mark_iterator const *)arg1)->operator *();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_mark_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::mark_iterator *arg1 = (spot::internal::mark_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__mark_iterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mark_iterator" "', argument " "1"" of type '" "spot::internal::mark_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::mark_iterator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *mark_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__mark_iterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mark_iterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_mark_container(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::internal::mark_container *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mark_container" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_mark_container" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = (spot::internal::mark_container *)new spot::internal::mark_container(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__mark_container, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_container_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::mark_container *arg1 = (spot::internal::mark_container *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::internal::mark_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__mark_container, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_container_begin" "', argument " "1"" of type '" "spot::internal::mark_container const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::mark_container * >(argp1);
  {
    try {
      result = ((spot::internal::mark_container const *)arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::mark_iterator(result)), SWIGTYPE_p_spot__internal__mark_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_container_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::mark_container *arg1 = (spot::internal::mark_container *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::internal::mark_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__mark_container, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_container_end" "', argument " "1"" of type '" "spot::internal::mark_container const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::mark_container * >(argp1);
  {
    try {
      result = ((spot::internal::mark_container const *)arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::mark_iterator(result)), SWIGTYPE_p_spot__internal__mark_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mark_container___iter__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::mark_container *arg1 = (spot::internal::mark_container *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__mark_container, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mark_container___iter__" "', argument " "1"" of type '" "spot::internal::mark_container *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::mark_container * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)spot_internal_mark_container___iter__(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_mark_container(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::mark_container *arg1 = (spot::internal::mark_container *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__mark_container, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mark_container" "', argument " "1"" of type '" "spot::internal::mark_container *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::mark_container * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *mark_container_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__mark_container, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mark_container_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_pair_bool_mark__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< bool,spot::acc_cond::mark_t > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< bool,spot::acc_cond::mark_t > *)new std::pair< bool,spot::acc_cond::mark_t >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pair_bool_mark__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  spot::acc_cond::mark_t arg2 ;
  bool val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::pair< bool,spot::acc_cond::mark_t > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_pair_bool_mark" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_pair_bool_mark" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pair_bool_mark" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (std::pair< bool,spot::acc_cond::mark_t > *)new std::pair< bool,spot::acc_cond::mark_t >(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_pair_bool_mark__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< bool,spot::acc_cond::mark_t > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< bool,spot::acc_cond::mark_t > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< bool,spot::acc_cond::mark_t > *ptr = (std::pair< bool,spot::acc_cond::mark_t > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_pair_bool_mark" "', argument " "1"" of type '" "std::pair< bool,spot::acc_cond::mark_t > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_pair_bool_mark" "', argument " "1"" of type '" "std::pair< bool,spot::acc_cond::mark_t > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< bool,spot::acc_cond::mark_t > *)new std::pair< bool,spot::acc_cond::mark_t >((std::pair< bool,spot::acc_cond::mark_t > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_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_new_pair_bool_mark(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_pair_bool_mark", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_pair_bool_mark__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_pair_bool_mark__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_pair_bool_mark__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_pair_bool_mark'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< bool,spot::acc_cond::mark_t >::pair()\n"
    "    std::pair< bool,spot::acc_cond::mark_t >::pair(bool,spot::acc_cond::mark_t)\n"
    "    std::pair< bool,spot::acc_cond::mark_t >::pair(std::pair< bool,spot::acc_cond::mark_t > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_pair_bool_mark_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< bool,spot::acc_cond::mark_t > *arg1 = (std::pair< bool,spot::acc_cond::mark_t > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pair_bool_mark_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_bool_mark_first_set" "', argument " "1"" of type '" "std::pair< bool,spot::acc_cond::mark_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< bool,spot::acc_cond::mark_t > * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pair_bool_mark_first_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->first = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pair_bool_mark_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< bool,spot::acc_cond::mark_t > *arg1 = (std::pair< bool,spot::acc_cond::mark_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_bool_mark_first_get" "', argument " "1"" of type '" "std::pair< bool,spot::acc_cond::mark_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< bool,spot::acc_cond::mark_t > * >(argp1);
  result = (bool) ((arg1)->first);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pair_bool_mark_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< bool,spot::acc_cond::mark_t > *arg1 = (std::pair< bool,spot::acc_cond::mark_t > *) 0 ;
  spot::acc_cond::mark_t *arg2 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pair_bool_mark_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_bool_mark_second_set" "', argument " "1"" of type '" "std::pair< bool,spot::acc_cond::mark_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< bool,spot::acc_cond::mark_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pair_bool_mark_second_set" "', argument " "2"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
  if (arg1) (arg1)->second = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pair_bool_mark_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< bool,spot::acc_cond::mark_t > *arg1 = (std::pair< bool,spot::acc_cond::mark_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pair_bool_mark_second_get" "', argument " "1"" of type '" "std::pair< bool,spot::acc_cond::mark_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< bool,spot::acc_cond::mark_t > * >(argp1);
  result = (spot::acc_cond::mark_t *)& ((arg1)->second);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_pair_bool_mark(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< bool,spot::acc_cond::mark_t > *arg1 = (std::pair< bool,spot::acc_cond::mark_t > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pair_bool_mark" "', argument " "1"" of type '" "std::pair< bool,spot::acc_cond::mark_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< bool,spot::acc_cond::mark_t > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *pair_bool_mark_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_bool_spot__acc_cond__mark_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pair_bool_mark_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_state_compare(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state *arg1 = (spot::state *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "state_compare", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_compare" "', argument " "1"" of type '" "spot::state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "state_compare" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (int)((spot::state const *)arg1)->compare((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_state_hash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state *arg1 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_hash" "', argument " "1"" of type '" "spot::state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state * >(argp1);
  {
    try {
      result = ((spot::state const *)arg1)->hash();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_state_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state *arg1 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_clone" "', argument " "1"" of type '" "spot::state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state * >(argp1);
  {
    try {
      result = (spot::state *)((spot::state const *)arg1)->clone();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_state_destroy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state *arg1 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_destroy" "', argument " "1"" of type '" "spot::state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state * >(argp1);
  {
    try {
      ((spot::state const *)arg1)->destroy();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *state_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__state, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_state_ptr_less_than___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_ptr_less_than *arg1 = (spot::state_ptr_less_than *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  spot::state *arg3 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "state_ptr_less_than___call__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_ptr_less_than, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_ptr_less_than___call__" "', argument " "1"" of type '" "spot::state_ptr_less_than const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_ptr_less_than * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "state_ptr_less_than___call__" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "state_ptr_less_than___call__" "', argument " "3"" of type '" "spot::state const *""'"); 
  }
  arg3 = reinterpret_cast< spot::state * >(argp3);
  {
    try {
      result = (bool)((spot::state_ptr_less_than const *)arg1)->operator ()((spot::state const *)arg2,(spot::state const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_state_ptr_less_than(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_ptr_less_than *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_state_ptr_less_than", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::state_ptr_less_than *)new spot::state_ptr_less_than();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state_ptr_less_than, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_state_ptr_less_than(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_ptr_less_than *arg1 = (spot::state_ptr_less_than *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_ptr_less_than, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_state_ptr_less_than" "', argument " "1"" of type '" "spot::state_ptr_less_than *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_ptr_less_than * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *state_ptr_less_than_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__state_ptr_less_than, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *state_ptr_less_than_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_state_ptr_equal___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_ptr_equal *arg1 = (spot::state_ptr_equal *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  spot::state *arg3 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "state_ptr_equal___call__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_ptr_equal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_ptr_equal___call__" "', argument " "1"" of type '" "spot::state_ptr_equal const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_ptr_equal * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "state_ptr_equal___call__" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "state_ptr_equal___call__" "', argument " "3"" of type '" "spot::state const *""'"); 
  }
  arg3 = reinterpret_cast< spot::state * >(argp3);
  {
    try {
      result = (bool)((spot::state_ptr_equal const *)arg1)->operator ()((spot::state const *)arg2,(spot::state const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_state_ptr_equal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_ptr_equal *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_state_ptr_equal", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::state_ptr_equal *)new spot::state_ptr_equal();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state_ptr_equal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_state_ptr_equal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_ptr_equal *arg1 = (spot::state_ptr_equal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_ptr_equal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_state_ptr_equal" "', argument " "1"" of type '" "spot::state_ptr_equal *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_ptr_equal * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *state_ptr_equal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__state_ptr_equal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *state_ptr_equal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_state_ptr_hash___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_ptr_hash *arg1 = (spot::state_ptr_hash *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  size_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "state_ptr_hash___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_ptr_hash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_ptr_hash___call__" "', argument " "1"" of type '" "spot::state_ptr_hash const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_ptr_hash * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "state_ptr_hash___call__" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = ((spot::state_ptr_hash const *)arg1)->operator ()((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_state_ptr_hash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_ptr_hash *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_state_ptr_hash", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::state_ptr_hash *)new spot::state_ptr_hash();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state_ptr_hash, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_state_ptr_hash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_ptr_hash *arg1 = (spot::state_ptr_hash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_ptr_hash, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_state_ptr_hash" "', argument " "1"" of type '" "spot::state_ptr_hash *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_ptr_hash * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *state_ptr_hash_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__state_ptr_hash, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *state_ptr_hash_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_state_unicity_table___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_unicity_table *arg1 = (spot::state_unicity_table *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::state *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "state_unicity_table___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_unicity_table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_unicity_table___call__" "', argument " "1"" of type '" "spot::state_unicity_table *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_unicity_table * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "state_unicity_table___call__" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (spot::state *)(arg1)->operator ()((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_state_unicity_table_is_new(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_unicity_table *arg1 = (spot::state_unicity_table *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::state *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "state_unicity_table_is_new", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_unicity_table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_unicity_table_is_new" "', argument " "1"" of type '" "spot::state_unicity_table *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_unicity_table * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "state_unicity_table_is_new" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (spot::state *)(arg1)->is_new((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_state_unicity_table(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_unicity_table *arg1 = (spot::state_unicity_table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_unicity_table, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_state_unicity_table" "', argument " "1"" of type '" "spot::state_unicity_table *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_unicity_table * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_state_unicity_table_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_unicity_table *arg1 = (spot::state_unicity_table *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_unicity_table, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_unicity_table_size" "', argument " "1"" of type '" "spot::state_unicity_table *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_unicity_table * >(argp1);
  {
    try {
      result = (arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_state_unicity_table(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_unicity_table *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_state_unicity_table", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::state_unicity_table *)new spot::state_unicity_table();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state_unicity_table, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *state_unicity_table_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__state_unicity_table, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *state_unicity_table_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_shared_state_deleter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state *arg1 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shared_state_deleter" "', argument " "1"" of type '" "spot::state *""'"); 
  }
  arg1 = reinterpret_cast< spot::state * >(argp1);
  {
    try {
      spot::shared_state_deleter(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_state_shared_ptr_less_than___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_shared_ptr_less_than *arg1 = (spot::state_shared_ptr_less_than *) 0 ;
  SwigValueWrapper< std::shared_ptr< spot::state const > > arg2 ;
  SwigValueWrapper< std::shared_ptr< spot::state const > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "state_shared_ptr_less_than___call__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_shared_ptr_less_than, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_shared_ptr_less_than___call__" "', argument " "1"" of type '" "spot::state_shared_ptr_less_than const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_shared_ptr_less_than * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__state_const_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "state_shared_ptr_less_than___call__" "', argument " "2"" of type '" "spot::shared_state""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "state_shared_ptr_less_than___call__" "', argument " "2"" of type '" "spot::shared_state""'");
    } else {
      spot::shared_state * temp = reinterpret_cast< spot::shared_state * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__state_const_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "state_shared_ptr_less_than___call__" "', argument " "3"" of type '" "spot::shared_state""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "state_shared_ptr_less_than___call__" "', argument " "3"" of type '" "spot::shared_state""'");
    } else {
      spot::shared_state * temp = reinterpret_cast< spot::shared_state * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::state_shared_ptr_less_than const *)arg1)->operator ()(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_state_shared_ptr_less_than(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_shared_ptr_less_than *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_state_shared_ptr_less_than", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::state_shared_ptr_less_than *)new spot::state_shared_ptr_less_than();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state_shared_ptr_less_than, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_state_shared_ptr_less_than(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_shared_ptr_less_than *arg1 = (spot::state_shared_ptr_less_than *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_shared_ptr_less_than, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_state_shared_ptr_less_than" "', argument " "1"" of type '" "spot::state_shared_ptr_less_than *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_shared_ptr_less_than * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *state_shared_ptr_less_than_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__state_shared_ptr_less_than, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *state_shared_ptr_less_than_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_state_shared_ptr_equal___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_shared_ptr_equal *arg1 = (spot::state_shared_ptr_equal *) 0 ;
  SwigValueWrapper< std::shared_ptr< spot::state const > > arg2 ;
  SwigValueWrapper< std::shared_ptr< spot::state const > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "state_shared_ptr_equal___call__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_shared_ptr_equal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_shared_ptr_equal___call__" "', argument " "1"" of type '" "spot::state_shared_ptr_equal const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_shared_ptr_equal * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__state_const_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "state_shared_ptr_equal___call__" "', argument " "2"" of type '" "spot::shared_state""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "state_shared_ptr_equal___call__" "', argument " "2"" of type '" "spot::shared_state""'");
    } else {
      spot::shared_state * temp = reinterpret_cast< spot::shared_state * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__state_const_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "state_shared_ptr_equal___call__" "', argument " "3"" of type '" "spot::shared_state""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "state_shared_ptr_equal___call__" "', argument " "3"" of type '" "spot::shared_state""'");
    } else {
      spot::shared_state * temp = reinterpret_cast< spot::shared_state * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::state_shared_ptr_equal const *)arg1)->operator ()(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_state_shared_ptr_equal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_shared_ptr_equal *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_state_shared_ptr_equal", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::state_shared_ptr_equal *)new spot::state_shared_ptr_equal();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state_shared_ptr_equal, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_state_shared_ptr_equal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_shared_ptr_equal *arg1 = (spot::state_shared_ptr_equal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_shared_ptr_equal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_state_shared_ptr_equal" "', argument " "1"" of type '" "spot::state_shared_ptr_equal *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_shared_ptr_equal * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *state_shared_ptr_equal_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__state_shared_ptr_equal, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *state_shared_ptr_equal_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_state_shared_ptr_hash___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_shared_ptr_hash *arg1 = (spot::state_shared_ptr_hash *) 0 ;
  SwigValueWrapper< std::shared_ptr< spot::state const > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  size_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "state_shared_ptr_hash___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_shared_ptr_hash, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_shared_ptr_hash___call__" "', argument " "1"" of type '" "spot::state_shared_ptr_hash const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_shared_ptr_hash * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__state_const_t,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "state_shared_ptr_hash___call__" "', argument " "2"" of type '" "spot::shared_state""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "state_shared_ptr_hash___call__" "', argument " "2"" of type '" "spot::shared_state""'");
    } else {
      spot::shared_state * temp = reinterpret_cast< spot::shared_state * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = ((spot::state_shared_ptr_hash const *)arg1)->operator ()(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_state_shared_ptr_hash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_shared_ptr_hash *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_state_shared_ptr_hash", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::state_shared_ptr_hash *)new spot::state_shared_ptr_hash();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state_shared_ptr_hash, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_state_shared_ptr_hash(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_shared_ptr_hash *arg1 = (spot::state_shared_ptr_hash *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_shared_ptr_hash, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_state_shared_ptr_hash" "', argument " "1"" of type '" "spot::state_shared_ptr_hash *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_shared_ptr_hash * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *state_shared_ptr_hash_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__state_shared_ptr_hash, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *state_shared_ptr_hash_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_twa_succ_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_succ_iterator *arg1 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_succ_iterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_succ_iterator" "', argument " "1"" of type '" "spot::twa_succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_succ_iterator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_succ_iterator_first(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_succ_iterator *arg1 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_succ_iterator_first" "', argument " "1"" of type '" "spot::twa_succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_succ_iterator * >(argp1);
  {
    try {
      result = (bool)(arg1)->first();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_succ_iterator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_succ_iterator *arg1 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_succ_iterator_next" "', argument " "1"" of type '" "spot::twa_succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_succ_iterator * >(argp1);
  {
    try {
      result = (bool)(arg1)->next();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_succ_iterator_done(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_succ_iterator *arg1 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_succ_iterator_done" "', argument " "1"" of type '" "spot::twa_succ_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_succ_iterator * >(argp1);
  {
    try {
      result = (bool)((spot::twa_succ_iterator const *)arg1)->done();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_succ_iterator_dst(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_succ_iterator *arg1 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_succ_iterator_dst" "', argument " "1"" of type '" "spot::twa_succ_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_succ_iterator * >(argp1);
  {
    try {
      result = (spot::state *)((spot::twa_succ_iterator const *)arg1)->dst();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_succ_iterator_cond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_succ_iterator *arg1 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bdd result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_succ_iterator_cond" "', argument " "1"" of type '" "spot::twa_succ_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_succ_iterator * >(argp1);
  {
    try {
      result = ((spot::twa_succ_iterator const *)arg1)->cond();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_succ_iterator_acc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_succ_iterator *arg1 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_succ_iterator_acc" "', argument " "1"" of type '" "spot::twa_succ_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_succ_iterator * >(argp1);
  {
    try {
      result = ((spot::twa_succ_iterator const *)arg1)->acc();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_succ_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__twa_succ_iterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_succ_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_succ_iterator *arg1 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::internal::succ_iterator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_succ_iterator" "', argument " "1"" of type '" "spot::twa_succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_succ_iterator * >(argp1);
  {
    try {
      result = (spot::internal::succ_iterator *)new spot::internal::succ_iterator(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__succ_iterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_succ_iterator___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::succ_iterator *arg1 = (spot::internal::succ_iterator *) 0 ;
  SwigValueWrapper< spot::internal::succ_iterator > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "succ_iterator___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "succ_iterator___eq__" "', argument " "1"" of type '" "spot::internal::succ_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::succ_iterator * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__succ_iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "succ_iterator___eq__" "', argument " "2"" of type '" "spot::internal::succ_iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "succ_iterator___eq__" "', argument " "2"" of type '" "spot::internal::succ_iterator""'");
    } else {
      spot::internal::succ_iterator * temp = reinterpret_cast< spot::internal::succ_iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::internal::succ_iterator const *)arg1)->operator ==(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_succ_iterator___ne__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::succ_iterator *arg1 = (spot::internal::succ_iterator *) 0 ;
  SwigValueWrapper< spot::internal::succ_iterator > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "succ_iterator___ne__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "succ_iterator___ne__" "', argument " "1"" of type '" "spot::internal::succ_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::succ_iterator * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__succ_iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "succ_iterator___ne__" "', argument " "2"" of type '" "spot::internal::succ_iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "succ_iterator___ne__" "', argument " "2"" of type '" "spot::internal::succ_iterator""'");
    } else {
      spot::internal::succ_iterator * temp = reinterpret_cast< spot::internal::succ_iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (bool)((spot::internal::succ_iterator const *)arg1)->operator !=(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_succ_iterator___ref__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::succ_iterator *arg1 = (spot::internal::succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_succ_iterator *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "succ_iterator___ref__" "', argument " "1"" of type '" "spot::internal::succ_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::succ_iterator * >(argp1);
  {
    try {
      result = (spot::twa_succ_iterator *)((spot::internal::succ_iterator const *)arg1)->operator *();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_succ_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::succ_iterator *arg1 = (spot::internal::succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__succ_iterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_succ_iterator" "', argument " "1"" of type '" "spot::internal::succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::succ_iterator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *succ_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__succ_iterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *succ_iterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_twa(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_get_init_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_get_init_state" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::state *)((spot::twa const *)arg1)->get_init_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_succ_iter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::twa_succ_iterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_succ_iter", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_succ_iter" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_succ_iter" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (spot::twa_succ_iterator *)((spot::twa const *)arg1)->succ_iter((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_release_iter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::twa_succ_iterator *arg2 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_release_iter", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_release_iter" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_release_iter" "', argument " "2"" of type '" "spot::twa_succ_iterator *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_succ_iterator * >(argp2);
  {
    try {
      ((spot::twa const *)arg1)->release_iter(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_get_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::bdd_dict_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_get_dict" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->get_dict();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::bdd_dict > *smartresult = result ? new std::shared_ptr<  spot::bdd_dict >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_register_ap__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_register_ap" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "twa_register_ap" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (int)(arg1)->register_ap(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_register_ap__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_register_ap" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    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 '" "twa_register_ap" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (int)(arg1)->register_ap(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_register_ap(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_register_ap", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_twa_register_ap__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_register_ap__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_register_ap'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::register_ap(spot::formula)\n"
    "    spot::twa::register_ap(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_unregister_ap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_unregister_ap", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_unregister_ap" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_unregister_ap" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      (arg1)->unregister_ap(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_register_aps_from_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_register_aps_from_dict" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->register_aps_from_dict();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_ap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::formula,std::allocator< spot::formula > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_ap" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< spot::formula,std::allocator< spot::formula > > *) &((spot::twa const *)arg1)->ap();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< spot::formula,std::allocator< spot::formula > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_ap_vars(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bdd result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_ap_vars" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->ap_vars();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_format_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_format_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_format_state" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_format_state" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = ((spot::twa const *)arg1)->format_state((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_project_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  spot::const_twa_ptr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  spot::const_twa_ptr tempshared3 ;
  PyObject *swig_obj[3] ;
  spot::state *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_project_state", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_project_state" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_project_state" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "twa_project_state" "', argument " "3"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< spot::const_twa_ptr * >(argp3);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< spot::const_twa_ptr * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = (spot::state *)((spot::twa const *)arg1)->project_state((spot::state const *)arg2,(spot::const_twa_ptr const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_acc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::acc_cond *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_acc" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::acc_cond *) &((spot::twa const *)arg1)->acc();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_acc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  spot::acc_cond *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_acc" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::acc_cond *) &(arg1)->acc();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_acc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_acc", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_acc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_acc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_acc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::acc() const\n"
    "    spot::twa::acc()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_is_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_is_empty" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((spot::twa const *)arg1)->is_empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_accepting_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_run_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_accepting_run" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->accepting_run();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_accepting_word(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_word_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_accepting_word" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->accepting_word();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_word > *smartresult = result ? new std::shared_ptr<  spot::twa_word >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_intersects(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::const_twa_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_intersects", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_intersects" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_intersects" "', argument " "2"" of type '" "spot::const_twa_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
  }
  {
    try {
      result = (bool)((spot::twa const *)arg1)->intersects(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_intersecting_run__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::const_twa_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_run_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_intersecting_run" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_intersecting_run" "', argument " "2"" of type '" "spot::const_twa_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
  }
  {
    try {
      result = ((spot::twa const *)arg1)->intersecting_run(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_intersecting_run__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::const_twa_ptr arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_run_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_intersecting_run" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_intersecting_run" "', argument " "2"" of type '" "spot::const_twa_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "twa_intersecting_run" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = ((spot::twa const *)arg1)->intersecting_run(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_intersecting_run(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_intersecting_run", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_intersecting_run__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_twa_intersecting_run__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_intersecting_run'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::intersecting_run(spot::const_twa_ptr) const\n"
    "    spot::twa::intersecting_run(spot::const_twa_ptr,bool) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_intersecting_word(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::const_twa_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::twa_word_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_intersecting_word", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_intersecting_word" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_intersecting_word" "', argument " "2"" of type '" "spot::const_twa_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
  }
  {
    try {
      result = ((spot::twa const *)arg1)->intersecting_word(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_word > *smartresult = result ? new std::shared_ptr<  spot::twa_word >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_exclusive_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::const_twa_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::twa_run_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_exclusive_run", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_exclusive_run" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_exclusive_run" "', argument " "2"" of type '" "spot::const_twa_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
  }
  {
    try {
      result = ((spot::twa const *)arg1)->exclusive_run(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_exclusive_word(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::const_twa_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::twa_word_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_exclusive_word", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_exclusive_word" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_exclusive_word" "', argument " "2"" of type '" "spot::const_twa_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
  }
  {
    try {
      result = ((spot::twa const *)arg1)->exclusive_word(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_word > *smartresult = result ? new std::shared_ptr<  spot::twa_word >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_num_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_num_sets" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::twa const *)arg1)->num_sets();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_get_acceptance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::acc_code *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_get_acceptance" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::acc_cond::acc_code *) &((spot::twa const *)arg1)->get_acceptance();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__acc_code, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_set_acceptance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_set_acceptance" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_set_acceptance" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "twa_set_acceptance" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_set_acceptance" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  {
    try {
      (arg1)->set_acceptance(arg2,(spot::acc_cond::acc_code const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_set_acceptance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::acc_cond *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_set_acceptance" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_set_acceptance" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_set_acceptance" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond * >(argp2);
  {
    try {
      (arg1)->set_acceptance((spot::acc_cond const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_set_acceptance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_set_acceptance", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_set_acceptance__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_twa_set_acceptance__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_set_acceptance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::set_acceptance(unsigned int,spot::acc_cond::acc_code const &)\n"
    "    spot::twa::set_acceptance(spot::acc_cond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_copy_acceptance_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_copy_acceptance_of", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_copy_acceptance_of" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_copy_acceptance_of" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->copy_acceptance_of((spot::const_twa_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_copy_ap_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_copy_ap_of", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_copy_ap_of" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_copy_ap_of" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->copy_ap_of((spot::const_twa_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_copy_named_properties_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_copy_named_properties_of", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_copy_named_properties_of" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_copy_named_properties_of" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->copy_named_properties_of((spot::const_twa_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_set_generalized_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_set_generalized_buchi", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_set_generalized_buchi" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_set_generalized_buchi" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      (arg1)->set_generalized_buchi(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_set_generalized_co_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_set_generalized_co_buchi", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_set_generalized_co_buchi" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_set_generalized_co_buchi" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      (arg1)->set_generalized_co_buchi(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_set_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_set_buchi" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->set_buchi();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_set_co_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_set_co_buchi" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->set_co_buchi();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_release_named_properties(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_release_named_properties" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->release_named_properties();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_state_acc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_state_acc" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_state_acc();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_state_acc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_state_acc" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_state_acc" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_state_acc" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_state_acc(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_state_acc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_state_acc", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_state_acc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_state_acc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_state_acc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_state_acc() const\n"
    "    spot::twa::prop_state_acc(spot::trival)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_is_sba(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::trival result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_is_sba" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->is_sba();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_inherently_weak__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_inherently_weak" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_inherently_weak();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_inherently_weak__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_inherently_weak" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_inherently_weak" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_inherently_weak" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_inherently_weak(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_inherently_weak(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_inherently_weak", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_inherently_weak__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_inherently_weak__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_inherently_weak'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_inherently_weak() const\n"
    "    spot::twa::prop_inherently_weak(spot::trival)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_terminal__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_terminal" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_terminal();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_terminal__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_terminal" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_terminal" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_terminal" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_terminal(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_terminal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_terminal", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_terminal__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_terminal__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_terminal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_terminal() const\n"
    "    spot::twa::prop_terminal(spot::trival)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_weak__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_weak" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_weak();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_weak__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_weak" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_weak" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_weak" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_weak(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_weak(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_weak", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_weak__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_weak__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_weak'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_weak() const\n"
    "    spot::twa::prop_weak(spot::trival)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_very_weak__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_very_weak" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_very_weak();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_very_weak__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_very_weak" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_very_weak" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_very_weak" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_very_weak(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_very_weak(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_very_weak", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_very_weak__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_very_weak__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_very_weak'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_very_weak() const\n"
    "    spot::twa::prop_very_weak(spot::trival)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_complete__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_complete" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_complete();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_complete__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_complete" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_complete" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_complete" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_complete(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_complete(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_complete", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_complete__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_complete__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_complete'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_complete() const\n"
    "    spot::twa::prop_complete(spot::trival)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_universal__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_universal" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_universal();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_universal__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_universal" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_universal" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_universal" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_universal(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_universal(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_universal", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_universal__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_universal__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_universal'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_universal() const\n"
    "    spot::twa::prop_universal(spot::trival)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_deterministic__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_deterministic" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_deterministic" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_deterministic" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_deterministic(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_deterministic__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_deterministic" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_deterministic();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_deterministic(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_deterministic", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_deterministic__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_deterministic__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_deterministic'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_deterministic(spot::trival)\n"
    "    spot::twa::prop_deterministic() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_unambiguous__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_unambiguous" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_unambiguous();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_unambiguous__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_unambiguous" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_unambiguous" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_unambiguous" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_unambiguous(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_unambiguous(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_unambiguous", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_unambiguous__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_unambiguous__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_unambiguous'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_unambiguous() const\n"
    "    spot::twa::prop_unambiguous(spot::trival)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_semi_deterministic__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_semi_deterministic" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_semi_deterministic();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_semi_deterministic__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_semi_deterministic" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_semi_deterministic" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_semi_deterministic" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_semi_deterministic(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_semi_deterministic(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_semi_deterministic", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_semi_deterministic__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_semi_deterministic__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_semi_deterministic'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_semi_deterministic() const\n"
    "    spot::twa::prop_semi_deterministic(spot::trival)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_stutter_invariant__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa const > tempshared1 ;
  std::shared_ptr< spot::twa const > *smartarg1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_stutter_invariant" "', argument " "1"" of type '" "spot::twa const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa const *)arg1)->prop_stutter_invariant();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_stutter_invariant__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::trival arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_stutter_invariant" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__trival,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_stutter_invariant" "', argument " "2"" of type '" "spot::trival""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_stutter_invariant" "', argument " "2"" of type '" "spot::trival""'");
    } else {
      spot::trival * temp = reinterpret_cast< spot::trival * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_stutter_invariant(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_stutter_invariant(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_prop_stutter_invariant", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_prop_stutter_invariant__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_prop_stutter_invariant__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_prop_stutter_invariant'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_stutter_invariant() const\n"
    "    spot::twa::prop_stutter_invariant(spot::trival)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  spot::twa::prop_set arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_prop_copy", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_copy" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_copy" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "twa_prop_copy" "', argument " "3"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_copy" "', argument " "3"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_copy((spot::const_twa_ptr const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_keep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  spot::twa::prop_set arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_prop_keep", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_keep" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_prop_keep" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_prop_keep" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->prop_keep(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_reset" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->prop_reset();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_set_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_set_name", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_set_name" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    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 '" "twa_set_name" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      spot_twa_set_name(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_get_name(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_get_name" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::string *)spot_twa_get_name(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_FromCharPtr(result->c_str());
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_set_state_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  std::vector< std::string,std::allocator< std::string > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_set_state_names", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_set_state_names" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)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 '" "twa_set_state_names" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      spot_twa_set_state_names(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_get_state_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_get_state_names" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< std::string,std::allocator< std::string > > *)spot_twa_get_state_names(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_set_product_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_set_product_states", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_set_product_states" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *ptr = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,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 '" "twa_set_product_states" "', argument " "2"" of type '" "std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      spot_twa_set_product_states(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_get_product_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_get_product_states" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *)spot_twa_get_product_states(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  
  if (!result)
  resultobj = SWIG_Py_Void();
  else
  {
    unsigned sz = result->size();
    resultobj = PyList_New(sz);
    for (unsigned i = 0; i < sz; ++i)
    PyList_SetItem(resultobj, i, swig::from((*result)[i]));
  }
  
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_get_original_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_get_original_states" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< unsigned int,std::allocator< unsigned int > > *)spot_twa_get_original_states(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_get_original_classes(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_get_original_classes" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< unsigned int,std::allocator< unsigned int > > *)spot_twa_get_original_classes(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_highlight_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::twa *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_highlight_state", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_highlight_state" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_highlight_state" "', 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 '" "twa_highlight_state" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (spot::twa *)spot_twa_highlight_state(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa > *smartresult = result ? new std::shared_ptr<  spot::twa >(result SWIG_NO_NULL_DELETER_0) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_highlight_edge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa *arg1 = (spot::twa *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa > tempshared1 ;
  std::shared_ptr< spot::twa > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::twa *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_highlight_edge", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_highlight_edge" "', argument " "1"" of type '" "spot::twa *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa > * >(argp1);
      arg1 = const_cast< spot::twa * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_highlight_edge" "', 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 '" "twa_highlight_edge" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (spot::twa *)spot_twa_highlight_edge(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa > *smartresult = result ? new std::shared_ptr<  spot::twa >(result SWIG_NO_NULL_DELETER_0) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0 | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__twa_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_twa_prop_set_state_based_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_prop_set_state_based_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_state_based_set" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_prop_set_state_based_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->state_based = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_state_based_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_state_based_get" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  result = (bool) ((arg1)->state_based);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_inherently_weak_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_prop_set_inherently_weak_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_inherently_weak_set" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_prop_set_inherently_weak_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->inherently_weak = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_inherently_weak_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_inherently_weak_get" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  result = (bool) ((arg1)->inherently_weak);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_deterministic_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_prop_set_deterministic_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_deterministic_set" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_prop_set_deterministic_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->deterministic = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_deterministic_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_deterministic_get" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  result = (bool) ((arg1)->deterministic);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_improve_det_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_prop_set_improve_det_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_improve_det_set" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_prop_set_improve_det_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->improve_det = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_improve_det_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_improve_det_get" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  result = (bool) ((arg1)->improve_det);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_complete_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_prop_set_complete_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_complete_set" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_prop_set_complete_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->complete = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_complete_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_complete_get" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  result = (bool) ((arg1)->complete);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_stutter_inv_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_prop_set_stutter_inv_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_stutter_inv_set" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_prop_set_stutter_inv_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->stutter_inv = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_stutter_inv_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_prop_set_stutter_inv_get" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  result = (bool) ((arg1)->stutter_inv);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_prop_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::twa::prop_set *)new spot::twa::prop_set();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa__prop_set, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_prop_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::twa::prop_set *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_twa_prop_set" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_twa_prop_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_twa_prop_set" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_twa_prop_set" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_twa_prop_set" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_twa_prop_set" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (spot::twa::prop_set *)new spot::twa::prop_set(arg1,arg2,arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa__prop_set, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_prop_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_twa_prop_set", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_twa_prop_set__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_new_twa_prop_set__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_twa_prop_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa::prop_set::prop_set()\n"
    "    spot::twa::prop_set::prop_set(bool,bool,bool,bool,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_prop_set_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_prop_set_all", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = spot::twa::prop_set::all();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::twa::prop_set(result)), SWIGTYPE_p_spot__twa__prop_set, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_twa_prop_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa::prop_set *arg1 = (spot::twa::prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa__prop_set, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_prop_set" "', argument " "1"" of type '" "spot::twa::prop_set *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa::prop_set * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_prop_set_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__twa__prop_set, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_prop_set_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_create_atomic_prop_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::atomic_prop_set result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "create_atomic_prop_set" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = spot::create_atomic_prop_set(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_collect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::atomic_prop_set *arg2 = (spot::atomic_prop_set *) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::atomic_prop_set *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "atomic_prop_collect" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "atomic_prop_collect" "', argument " "2"" of type '" "spot::atomic_prop_set *""'"); 
  }
  arg2 = reinterpret_cast< spot::atomic_prop_set * >(argp2);
  {
    try {
      result = (spot::atomic_prop_set *)spot::atomic_prop_collect(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_collect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::atomic_prop_set *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "atomic_prop_collect" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = (spot::atomic_prop_set *)spot::atomic_prop_collect(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_atomic_prop_collect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "atomic_prop_collect", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_atomic_prop_collect__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_atomic_prop_collect__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'atomic_prop_collect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::atomic_prop_collect(spot::formula,spot::atomic_prop_set *)\n"
    "    spot::atomic_prop_collect(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_atomic_prop_collect_as_bdd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::twa_ptr *arg2 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  bdd result;
  
  if (!SWIG_Python_UnpackTuple(args, "atomic_prop_collect_as_bdd", 2, 2, swig_obj)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "atomic_prop_collect_as_bdd" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "atomic_prop_collect_as_bdd" "', argument " "2"" of type '" "spot::twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::twa_ptr * >(argp2);
      delete reinterpret_cast< spot::twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::atomic_prop_collect_as_bdd(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::twa > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_language_containment_checker__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  unsigned int arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  spot::language_containment_checker *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_language_containment_checker" "', argument " "1"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_language_containment_checker" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_language_containment_checker" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_language_containment_checker" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_language_containment_checker" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_language_containment_checker" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  {
    try {
      result = (spot::language_containment_checker *)new spot::language_containment_checker(arg1,arg2,arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__language_containment_checker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_language_containment_checker__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::language_containment_checker *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_language_containment_checker" "', argument " "1"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_language_containment_checker" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_language_containment_checker" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_language_containment_checker" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_language_containment_checker" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (spot::language_containment_checker *)new spot::language_containment_checker(arg1,arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__language_containment_checker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_language_containment_checker__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::language_containment_checker *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_language_containment_checker" "', argument " "1"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_language_containment_checker" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_language_containment_checker" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_language_containment_checker" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (spot::language_containment_checker *)new spot::language_containment_checker(arg1,arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__language_containment_checker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_language_containment_checker__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr arg1 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::language_containment_checker *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_language_containment_checker" "', argument " "1"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_language_containment_checker" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_language_containment_checker" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (spot::language_containment_checker *)new spot::language_containment_checker(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__language_containment_checker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_language_containment_checker__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::language_containment_checker *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_language_containment_checker" "', argument " "1"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_language_containment_checker" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (spot::language_containment_checker *)new spot::language_containment_checker(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__language_containment_checker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_language_containment_checker__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::language_containment_checker *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_language_containment_checker" "', argument " "1"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
  }
  {
    try {
      result = (spot::language_containment_checker *)new spot::language_containment_checker(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__language_containment_checker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_language_containment_checker__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::language_containment_checker *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::language_containment_checker *)new spot::language_containment_checker();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__language_containment_checker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_language_containment_checker(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_language_containment_checker", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_language_containment_checker__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_language_containment_checker__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_language_containment_checker__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_language_containment_checker__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_language_containment_checker__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_language_containment_checker__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_new_language_containment_checker__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_language_containment_checker'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::language_containment_checker::language_containment_checker(spot::bdd_dict_ptr,bool,bool,bool,bool,unsigned int)\n"
    "    spot::language_containment_checker::language_containment_checker(spot::bdd_dict_ptr,bool,bool,bool,bool)\n"
    "    spot::language_containment_checker::language_containment_checker(spot::bdd_dict_ptr,bool,bool,bool)\n"
    "    spot::language_containment_checker::language_containment_checker(spot::bdd_dict_ptr,bool,bool)\n"
    "    spot::language_containment_checker::language_containment_checker(spot::bdd_dict_ptr,bool)\n"
    "    spot::language_containment_checker::language_containment_checker(spot::bdd_dict_ptr)\n"
    "    spot::language_containment_checker::language_containment_checker()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_language_containment_checker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::language_containment_checker *arg1 = (spot::language_containment_checker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__language_containment_checker, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_language_containment_checker" "', argument " "1"" of type '" "spot::language_containment_checker *""'"); 
  }
  arg1 = reinterpret_cast< spot::language_containment_checker * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_language_containment_checker_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::language_containment_checker *arg1 = (spot::language_containment_checker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__language_containment_checker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "language_containment_checker_clear" "', argument " "1"" of type '" "spot::language_containment_checker *""'"); 
  }
  arg1 = reinterpret_cast< spot::language_containment_checker * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_language_containment_checker_contained(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::language_containment_checker *arg1 = (spot::language_containment_checker *) 0 ;
  spot::formula arg2 ;
  spot::formula arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "language_containment_checker_contained", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__language_containment_checker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "language_containment_checker_contained" "', argument " "1"" of type '" "spot::language_containment_checker *""'"); 
  }
  arg1 = reinterpret_cast< spot::language_containment_checker * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "language_containment_checker_contained" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "language_containment_checker_contained" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  {
    try {
      result = (bool)(arg1)->contained(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_language_containment_checker_neg_contained(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::language_containment_checker *arg1 = (spot::language_containment_checker *) 0 ;
  spot::formula arg2 ;
  spot::formula arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "language_containment_checker_neg_contained", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__language_containment_checker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "language_containment_checker_neg_contained" "', argument " "1"" of type '" "spot::language_containment_checker *""'"); 
  }
  arg1 = reinterpret_cast< spot::language_containment_checker * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "language_containment_checker_neg_contained" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "language_containment_checker_neg_contained" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  {
    try {
      result = (bool)(arg1)->neg_contained(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_language_containment_checker_contained_neg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::language_containment_checker *arg1 = (spot::language_containment_checker *) 0 ;
  spot::formula arg2 ;
  spot::formula arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "language_containment_checker_contained_neg", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__language_containment_checker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "language_containment_checker_contained_neg" "', argument " "1"" of type '" "spot::language_containment_checker *""'"); 
  }
  arg1 = reinterpret_cast< spot::language_containment_checker * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "language_containment_checker_contained_neg" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "language_containment_checker_contained_neg" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  {
    try {
      result = (bool)(arg1)->contained_neg(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_language_containment_checker_equal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::language_containment_checker *arg1 = (spot::language_containment_checker *) 0 ;
  spot::formula arg2 ;
  spot::formula arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "language_containment_checker_equal", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__language_containment_checker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "language_containment_checker_equal" "', argument " "1"" of type '" "spot::language_containment_checker *""'"); 
  }
  arg1 = reinterpret_cast< spot::language_containment_checker * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "language_containment_checker_equal" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "language_containment_checker_equal" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  {
    try {
      result = (bool)(arg1)->equal(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *language_containment_checker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__language_containment_checker, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *language_containment_checker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_print_dot_psl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "print_dot_psl", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_dot_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_dot_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_dot_psl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_dot_psl(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_negative_normal_form__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "negative_normal_form" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "negative_normal_form" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::negative_normal_form(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_negative_normal_form__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "negative_normal_form" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::negative_normal_form(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_negative_normal_form(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "negative_normal_form", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_negative_normal_form__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_negative_normal_form__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'negative_normal_form'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::negative_normal_form(spot::formula,bool)\n"
    "    spot::negative_normal_form(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_suffix_operator_normal_form(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::string arg2 ;
  PyObject *swig_obj[2] ;
  std::pair< spot::formula,std::vector< std::string,std::allocator< std::string > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "suffix_operator_normal_form", 2, 2, swig_obj)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "suffix_operator_normal_form" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    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 '" "suffix_operator_normal_form" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = spot::suffix_operator_normal_form(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< spot::formula,std::vector< std::string,std::allocator< std::string > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_psl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_psl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "print_psl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (std::ostream *) &spot::print_psl(*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_psl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_psl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_psl(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_psl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_psl", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_psl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_psl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_psl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_psl(std::ostream &,spot::formula,bool)\n"
    "    spot::print_psl(std::ostream &,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_str_psl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_psl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "str_psl" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::str_psl(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_psl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_psl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_psl(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_psl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "str_psl", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_str_psl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_str_psl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'str_psl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::str_psl(spot::formula,bool)\n"
    "    spot::str_psl(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_utf8_psl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_utf8_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_utf8_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_utf8_psl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "print_utf8_psl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (std::ostream *) &spot::print_utf8_psl(*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_utf8_psl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_utf8_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_utf8_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_utf8_psl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_utf8_psl(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_utf8_psl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_utf8_psl", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_utf8_psl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_utf8_psl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_utf8_psl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_utf8_psl(std::ostream &,spot::formula,bool)\n"
    "    spot::print_utf8_psl(std::ostream &,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_str_utf8_psl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_utf8_psl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "str_utf8_psl" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::str_utf8_psl(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_utf8_psl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_utf8_psl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_utf8_psl(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_utf8_psl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "str_utf8_psl", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_str_utf8_psl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_str_utf8_psl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'str_utf8_psl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::str_utf8_psl(spot::formula,bool)\n"
    "    spot::str_utf8_psl(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_sere__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_sere" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "print_sere" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (std::ostream *) &spot::print_sere(*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_sere__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_sere" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_sere(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_sere(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_sere", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_sere__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_sere__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_sere'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_sere(std::ostream &,spot::formula,bool)\n"
    "    spot::print_sere(std::ostream &,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_str_sere__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_sere" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "str_sere" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::str_sere(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_sere__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_sere" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_sere(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_sere(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "str_sere", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_str_sere__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_str_sere__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'str_sere'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::str_sere(spot::formula,bool)\n"
    "    spot::str_sere(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_utf8_sere__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_utf8_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_utf8_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_utf8_sere" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "print_utf8_sere" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (std::ostream *) &spot::print_utf8_sere(*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_utf8_sere__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_utf8_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_utf8_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_utf8_sere" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_utf8_sere(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_utf8_sere(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_utf8_sere", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_utf8_sere__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_utf8_sere__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_utf8_sere'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_utf8_sere(std::ostream &,spot::formula,bool)\n"
    "    spot::print_utf8_sere(std::ostream &,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_str_utf8_sere__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_utf8_sere" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "str_utf8_sere" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::str_utf8_sere(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_utf8_sere__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_utf8_sere" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_utf8_sere(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_utf8_sere(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "str_utf8_sere", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_str_utf8_sere__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_str_utf8_sere__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'str_utf8_sere'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::str_utf8_sere(spot::formula,bool)\n"
    "    spot::str_utf8_sere(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_spin_ltl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_spin_ltl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_spin_ltl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_spin_ltl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "print_spin_ltl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (std::ostream *) &spot::print_spin_ltl(*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_spin_ltl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_spin_ltl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_spin_ltl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_spin_ltl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_spin_ltl(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_spin_ltl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_spin_ltl", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_spin_ltl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_spin_ltl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_spin_ltl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_spin_ltl(std::ostream &,spot::formula,bool)\n"
    "    spot::print_spin_ltl(std::ostream &,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_str_spin_ltl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_spin_ltl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "str_spin_ltl" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::str_spin_ltl(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_spin_ltl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_spin_ltl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_spin_ltl(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_spin_ltl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "str_spin_ltl", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_str_spin_ltl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_str_spin_ltl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'str_spin_ltl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::str_spin_ltl(spot::formula,bool)\n"
    "    spot::str_spin_ltl(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_wring_ltl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "print_wring_ltl", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_wring_ltl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_wring_ltl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_wring_ltl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_wring_ltl(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_wring_ltl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_wring_ltl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_wring_ltl(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_latex_psl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_latex_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_latex_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_latex_psl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "print_latex_psl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (std::ostream *) &spot::print_latex_psl(*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_latex_psl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_latex_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_latex_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_latex_psl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_latex_psl(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_latex_psl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_latex_psl", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_latex_psl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_latex_psl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_latex_psl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_latex_psl(std::ostream &,spot::formula,bool)\n"
    "    spot::print_latex_psl(std::ostream &,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_str_latex_psl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_latex_psl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "str_latex_psl" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::str_latex_psl(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_latex_psl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_latex_psl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_latex_psl(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_latex_psl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "str_latex_psl", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_str_latex_psl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_str_latex_psl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'str_latex_psl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::str_latex_psl(spot::formula,bool)\n"
    "    spot::str_latex_psl(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_latex_sere__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_latex_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_latex_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_latex_sere" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "print_latex_sere" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (std::ostream *) &spot::print_latex_sere(*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_latex_sere__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_latex_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_latex_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_latex_sere" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_latex_sere(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_latex_sere(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_latex_sere", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_latex_sere__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_latex_sere__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_latex_sere'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_latex_sere(std::ostream &,spot::formula,bool)\n"
    "    spot::print_latex_sere(std::ostream &,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_str_latex_sere__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_latex_sere" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "str_latex_sere" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::str_latex_sere(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_latex_sere__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_latex_sere" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_latex_sere(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_latex_sere(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "str_latex_sere", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_str_latex_sere__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_str_latex_sere__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'str_latex_sere'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::str_latex_sere(spot::formula,bool)\n"
    "    spot::str_latex_sere(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_sclatex_psl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_sclatex_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_sclatex_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_sclatex_psl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "print_sclatex_psl" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (std::ostream *) &spot::print_sclatex_psl(*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_sclatex_psl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_sclatex_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_sclatex_psl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_sclatex_psl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_sclatex_psl(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_sclatex_psl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_sclatex_psl", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_sclatex_psl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_sclatex_psl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_sclatex_psl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_sclatex_psl(std::ostream &,spot::formula,bool)\n"
    "    spot::print_sclatex_psl(std::ostream &,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_str_sclatex_psl__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_sclatex_psl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "str_sclatex_psl" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::str_sclatex_psl(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_sclatex_psl__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_sclatex_psl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_sclatex_psl(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_sclatex_psl(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "str_sclatex_psl", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_str_sclatex_psl__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_str_sclatex_psl__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'str_sclatex_psl'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::str_sclatex_psl(spot::formula,bool)\n"
    "    spot::str_sclatex_psl(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_sclatex_sere__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_sclatex_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_sclatex_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_sclatex_sere" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "print_sclatex_sere" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (std::ostream *) &spot::print_sclatex_sere(*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_sclatex_sere__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_sclatex_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_sclatex_sere" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_sclatex_sere" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_sclatex_sere(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_sclatex_sere(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_sclatex_sere", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_sclatex_sere__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_sclatex_sere__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_sclatex_sere'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_sclatex_sere(std::ostream &,spot::formula,bool)\n"
    "    spot::print_sclatex_sere(std::ostream &,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_str_sclatex_sere__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool arg2 ;
  bool val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_sclatex_sere" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "str_sclatex_sere" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::str_sclatex_sere(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_sclatex_sere__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::string result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_sclatex_sere" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_sclatex_sere(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_sclatex_sere(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "str_sclatex_sere", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_str_sclatex_sere__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_str_sclatex_sere__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'str_sclatex_sere'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::str_sclatex_sere(spot::formula,bool)\n"
    "    spot::str_sclatex_sere(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_lbt_ltl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "print_lbt_ltl", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_lbt_ltl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_lbt_ltl" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "print_lbt_ltl" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (std::ostream *) &spot::print_lbt_ltl(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_lbt_ltl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "str_lbt_ltl" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::str_lbt_ltl(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  bool arg8 ;
  bool arg9 ;
  bool arg10 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_tl_simplifier_options" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_tl_simplifier_options" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_tl_simplifier_options" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_tl_simplifier_options" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_tl_simplifier_options" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_tl_simplifier_options" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_tl_simplifier_options" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_tl_simplifier_options" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_bool(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_tl_simplifier_options" "', argument " "10"" of type '" "bool""'");
  } 
  arg10 = static_cast< bool >(val10);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  bool arg8 ;
  bool arg9 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_tl_simplifier_options" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_tl_simplifier_options" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_tl_simplifier_options" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_tl_simplifier_options" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_tl_simplifier_options" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_tl_simplifier_options" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_tl_simplifier_options" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_tl_simplifier_options" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  bool arg8 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_tl_simplifier_options" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_tl_simplifier_options" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_tl_simplifier_options" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_tl_simplifier_options" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_tl_simplifier_options" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_tl_simplifier_options" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_tl_simplifier_options" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_tl_simplifier_options" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_tl_simplifier_options" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_tl_simplifier_options" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_tl_simplifier_options" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_tl_simplifier_options" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_tl_simplifier_options" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_tl_simplifier_options" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_tl_simplifier_options" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_tl_simplifier_options" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_tl_simplifier_options" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_tl_simplifier_options" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1,arg2,arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_tl_simplifier_options" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_tl_simplifier_options" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_tl_simplifier_options" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_tl_simplifier_options" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1,arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_tl_simplifier_options" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_tl_simplifier_options" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_tl_simplifier_options" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1,arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool arg3 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_tl_simplifier_options" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_tl_simplifier_options" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool arg2 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_tl_simplifier_options" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_9(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "bool""'");
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_10(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options__SWIG_11(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  spot::tl_simplifier_options *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_tl_simplifier_options" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (spot::tl_simplifier_options *)new spot::tl_simplifier_options(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier_options(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_tl_simplifier_options", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_10(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_bool(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_tl_simplifier_options__SWIG_9(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_11(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_8(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 8) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 9) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 10) {
    PyObject *retobj = _wrap_new_tl_simplifier_options__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_tl_simplifier_options'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(bool,bool,bool,bool,bool,bool,bool,bool,bool,bool)\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(bool,bool,bool,bool,bool,bool,bool,bool,bool)\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(bool,bool,bool,bool,bool,bool,bool,bool)\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(bool,bool,bool,bool,bool,bool,bool)\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(bool,bool,bool,bool,bool,bool)\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(bool,bool,bool,bool,bool)\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(bool,bool,bool,bool)\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(bool,bool,bool)\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(bool,bool)\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(bool)\n"
    "    spot::tl_simplifier_options::tl_simplifier_options()\n"
    "    spot::tl_simplifier_options::tl_simplifier_options(int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_reduce_basics_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_reduce_basics_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_reduce_basics_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_reduce_basics_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->reduce_basics = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_reduce_basics_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_reduce_basics_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (bool) ((arg1)->reduce_basics);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_synt_impl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_synt_impl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_synt_impl_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_synt_impl_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->synt_impl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_synt_impl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_synt_impl_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (bool) ((arg1)->synt_impl);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_event_univ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_event_univ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_event_univ_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_event_univ_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->event_univ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_event_univ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_event_univ_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (bool) ((arg1)->event_univ);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_containment_checks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_containment_checks_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_containment_checks_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_containment_checks_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->containment_checks = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_containment_checks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_containment_checks_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (bool) ((arg1)->containment_checks);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_containment_checks_stronger_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_containment_checks_stronger_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_containment_checks_stronger_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_containment_checks_stronger_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->containment_checks_stronger = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_containment_checks_stronger_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_containment_checks_stronger_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (bool) ((arg1)->containment_checks_stronger);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_nenoform_stop_on_boolean_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_nenoform_stop_on_boolean_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_nenoform_stop_on_boolean_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_nenoform_stop_on_boolean_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->nenoform_stop_on_boolean = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_nenoform_stop_on_boolean_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_nenoform_stop_on_boolean_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (bool) ((arg1)->nenoform_stop_on_boolean);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_reduce_size_strictly_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_reduce_size_strictly_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_reduce_size_strictly_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_reduce_size_strictly_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->reduce_size_strictly = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_reduce_size_strictly_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_reduce_size_strictly_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (bool) ((arg1)->reduce_size_strictly);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_boolean_to_isop_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_boolean_to_isop_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_boolean_to_isop_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_boolean_to_isop_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->boolean_to_isop = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_boolean_to_isop_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_boolean_to_isop_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (bool) ((arg1)->boolean_to_isop);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_favor_event_univ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_favor_event_univ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_favor_event_univ_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_favor_event_univ_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->favor_event_univ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_favor_event_univ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_favor_event_univ_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (bool) ((arg1)->favor_event_univ);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_keep_top_xor_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_keep_top_xor_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_keep_top_xor_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_keep_top_xor_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->keep_top_xor = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_keep_top_xor_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_keep_top_xor_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (bool) ((arg1)->keep_top_xor);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_containment_max_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_containment_max_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_containment_max_states_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_containment_max_states_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->containment_max_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_containment_max_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_containment_max_states_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (unsigned int) ((arg1)->containment_max_states);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_containment_max_ops_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_options_containment_max_ops_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_containment_max_ops_set" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tl_simplifier_options_containment_max_ops_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->containment_max_ops = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_options_containment_max_ops_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_options_containment_max_ops_get" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  result = (unsigned int) ((arg1)->containment_max_ops);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_tl_simplifier_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = (spot::tl_simplifier_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier_options, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_tl_simplifier_options" "', argument " "1"" of type '" "spot::tl_simplifier_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *tl_simplifier_options_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__tl_simplifier_options, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *tl_simplifier_options_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_tl_simplifier__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  spot::tl_simplifier *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_tl_simplifier" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::tl_simplifier *)new spot::tl_simplifier((spot::bdd_dict_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::tl_simplifier *)new spot::tl_simplifier();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = 0 ;
  spot::bdd_dict_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::tl_simplifier *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__tl_simplifier_options,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_tl_simplifier" "', argument " "1"" of type '" "spot::tl_simplifier_options const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_tl_simplifier" "', argument " "1"" of type '" "spot::tl_simplifier_options const &""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_tl_simplifier" "', argument " "2"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
  }
  {
    try {
      result = (spot::tl_simplifier *)new spot::tl_simplifier((spot::tl_simplifier_options const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::tl_simplifier_options *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::tl_simplifier *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__tl_simplifier_options,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_tl_simplifier" "', argument " "1"" of type '" "spot::tl_simplifier_options const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_tl_simplifier" "', argument " "1"" of type '" "spot::tl_simplifier_options const &""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier_options * >(argp1);
  {
    try {
      result = (spot::tl_simplifier *)new spot::tl_simplifier((spot::tl_simplifier_options const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__tl_simplifier, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_tl_simplifier(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_tl_simplifier", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_tl_simplifier__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_tl_simplifier__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_tl_simplifier__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_tl_simplifier__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_tl_simplifier'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::tl_simplifier::tl_simplifier(spot::bdd_dict_ptr const &)\n"
    "    spot::tl_simplifier::tl_simplifier()\n"
    "    spot::tl_simplifier::tl_simplifier(spot::tl_simplifier_options const &,spot::bdd_dict_ptr)\n"
    "    spot::tl_simplifier::tl_simplifier(spot::tl_simplifier_options const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_tl_simplifier(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_tl_simplifier" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_simplify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_simplify", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_simplify" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_simplify" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (arg1)->simplify(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_negative_normal_form__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_negative_normal_form" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_negative_normal_form" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tl_simplifier_negative_normal_form" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (arg1)->negative_normal_form(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_negative_normal_form__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_negative_normal_form" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_negative_normal_form" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (arg1)->negative_normal_form(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_negative_normal_form(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "tl_simplifier_negative_normal_form", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_tl_simplifier_negative_normal_form__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_tl_simplifier_negative_normal_form__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'tl_simplifier_negative_normal_form'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::tl_simplifier::negative_normal_form(spot::formula,bool)\n"
    "    spot::tl_simplifier::negative_normal_form(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_syntactic_implication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::formula arg2 ;
  spot::formula arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_syntactic_implication", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_syntactic_implication" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_syntactic_implication" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_syntactic_implication" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  {
    try {
      result = (bool)(arg1)->syntactic_implication(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_syntactic_implication_neg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::formula arg2 ;
  spot::formula arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  PyObject *swig_obj[4] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_syntactic_implication_neg", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_syntactic_implication_neg" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_syntactic_implication_neg" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_syntactic_implication_neg" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tl_simplifier_syntactic_implication_neg" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (bool)(arg1)->syntactic_implication_neg(arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_are_equivalent(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::formula arg2 ;
  spot::formula arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_are_equivalent", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_are_equivalent" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_are_equivalent" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_are_equivalent" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  {
    try {
      result = (bool)(arg1)->are_equivalent(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_implication(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::formula arg2 ;
  spot::formula arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[3] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_implication", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_implication" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_implication" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_implication" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  {
    try {
      result = (bool)(arg1)->implication(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_as_bdd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  bdd result;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_as_bdd", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_as_bdd" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_as_bdd" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (arg1)->as_bdd(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_clear_as_bdd_cache(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_clear_as_bdd_cache" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    try {
      (arg1)->clear_as_bdd_cache();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_clear_caches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_clear_caches" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    try {
      (arg1)->clear_caches();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_get_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::bdd_dict_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_get_dict" "', argument " "1"" of type '" "spot::tl_simplifier const *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    try {
      result = ((spot::tl_simplifier const *)arg1)->get_dict();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::bdd_dict > *smartresult = result ? new std::shared_ptr<  spot::bdd_dict >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_star_normal_form(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_star_normal_form", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_star_normal_form" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_star_normal_form" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (arg1)->star_normal_form(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_boolean_to_isop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_boolean_to_isop", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_boolean_to_isop" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tl_simplifier_boolean_to_isop" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (arg1)->boolean_to_isop(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tl_simplifier_print_stats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "tl_simplifier_print_stats", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tl_simplifier_print_stats" "', argument " "1"" of type '" "spot::tl_simplifier const *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tl_simplifier_print_stats" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tl_simplifier_print_stats" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      ((spot::tl_simplifier const *)arg1)->print_stats(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *tl_simplifier_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__tl_simplifier, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *tl_simplifier_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_default_unabbrev_string_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable default_unabbrev_string is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_default_unabbrev_string_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(spot::default_unabbrev_string);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_new_unabbreviator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  spot::unabbreviator *result = 0 ;
  
  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 '" "new_unabbreviator" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (spot::unabbreviator *)new spot::unabbreviator((char const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__unabbreviator, 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_unabbreviator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::unabbreviator *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::unabbreviator *)new spot::unabbreviator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__unabbreviator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_unabbreviator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_unabbreviator", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_unabbreviator__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_unabbreviator__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_unabbreviator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::unabbreviator::unabbreviator(char const *)\n"
    "    spot::unabbreviator::unabbreviator()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_unabbreviator_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::unabbreviator *arg1 = (spot::unabbreviator *) 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "unabbreviator_run", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__unabbreviator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unabbreviator_run" "', argument " "1"" of type '" "spot::unabbreviator *""'"); 
  }
  arg1 = reinterpret_cast< spot::unabbreviator * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "unabbreviator_run" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (arg1)->run(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_unabbreviator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::unabbreviator *arg1 = (spot::unabbreviator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__unabbreviator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_unabbreviator" "', argument " "1"" of type '" "spot::unabbreviator *""'"); 
  }
  arg1 = reinterpret_cast< spot::unabbreviator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *unabbreviator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__unabbreviator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *unabbreviator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_unabbreviate__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "unabbreviate" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "unabbreviate" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::unabbreviate(SWIG_STD_MOVE(arg1),(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_unabbreviate__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "unabbreviate" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::unabbreviate(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_unabbreviate(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "unabbreviate", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_unabbreviate__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_unabbreviate__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'unabbreviate'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::unabbreviate(spot::formula,char const *)\n"
    "    spot::unabbreviate(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_random_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  spot::atomic_prop_set *arg2 = (spot::atomic_prop_set *) 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::random_formula *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_random_formula", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_random_formula" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_random_formula" "', argument " "2"" of type '" "spot::atomic_prop_set const *""'"); 
  }
  arg2 = reinterpret_cast< spot::atomic_prop_set * >(argp2);
  {
    try {
      result = (spot::random_formula *)new spot::random_formula(arg1,(spot::atomic_prop_set const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__random_formula, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_random_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_formula *arg1 = (spot::random_formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_formula, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_random_formula" "', argument " "1"" of type '" "spot::random_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_formula * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_formula_ap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_formula *arg1 = (spot::random_formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::atomic_prop_set *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_formula_ap" "', argument " "1"" of type '" "spot::random_formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_formula * >(argp1);
  {
    try {
      result = (spot::atomic_prop_set *)((spot::random_formula const *)arg1)->ap();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_formula_generate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_formula *arg1 = (spot::random_formula *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "random_formula_generate", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_formula_generate" "', argument " "1"" of type '" "spot::random_formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_formula * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "random_formula_generate" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = ((spot::random_formula const *)arg1)->generate(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_formula_dump_priorities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_formula *arg1 = (spot::random_formula *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "random_formula_dump_priorities", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_formula_dump_priorities" "', argument " "1"" of type '" "spot::random_formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_formula_dump_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "random_formula_dump_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::random_formula const *)arg1)->dump_priorities(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_formula_parse_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_formula *arg1 = (spot::random_formula *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "random_formula_parse_options", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_formula_parse_options" "', argument " "1"" of type '" "spot::random_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_formula * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_formula_parse_options" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->parse_options(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *random_formula_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__random_formula, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *random_formula_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_random_ltl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::atomic_prop_set *arg1 = (spot::atomic_prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::random_ltl *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_random_ltl" "', argument " "1"" of type '" "spot::atomic_prop_set const *""'"); 
  }
  arg1 = reinterpret_cast< spot::atomic_prop_set * >(argp1);
  {
    try {
      result = (spot::random_ltl *)new spot::random_ltl((spot::atomic_prop_set const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__random_ltl, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_random_ltl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_ltl *arg1 = (spot::random_ltl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_ltl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_random_ltl" "', argument " "1"" of type '" "spot::random_ltl *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_ltl * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *random_ltl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__random_ltl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *random_ltl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_random_boolean(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::atomic_prop_set *arg1 = (spot::atomic_prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::random_boolean *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_random_boolean" "', argument " "1"" of type '" "spot::atomic_prop_set const *""'"); 
  }
  arg1 = reinterpret_cast< spot::atomic_prop_set * >(argp1);
  {
    try {
      result = (spot::random_boolean *)new spot::random_boolean((spot::atomic_prop_set const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__random_boolean, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_random_boolean(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_boolean *arg1 = (spot::random_boolean *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_boolean, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_random_boolean" "', argument " "1"" of type '" "spot::random_boolean *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_boolean * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *random_boolean_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__random_boolean, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *random_boolean_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_random_sere(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::atomic_prop_set *arg1 = (spot::atomic_prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::random_sere *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_random_sere" "', argument " "1"" of type '" "spot::atomic_prop_set const *""'"); 
  }
  arg1 = reinterpret_cast< spot::atomic_prop_set * >(argp1);
  {
    try {
      result = (spot::random_sere *)new spot::random_sere((spot::atomic_prop_set const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__random_sere, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_sere_rb_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_sere *arg1 = (spot::random_sere *) 0 ;
  spot::random_boolean *arg2 = (spot::random_boolean *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "random_sere_rb_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_sere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_sere_rb_set" "', argument " "1"" of type '" "spot::random_sere *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_sere * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__random_boolean, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_sere_rb_set" "', argument " "2"" of type '" "spot::random_boolean *""'"); 
  }
  arg2 = reinterpret_cast< spot::random_boolean * >(argp2);
  if (arg1) (arg1)->rb = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_sere_rb_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_sere *arg1 = (spot::random_sere *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::random_boolean *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_sere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_sere_rb_get" "', argument " "1"" of type '" "spot::random_sere *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_sere * >(argp1);
  result = (spot::random_boolean *)& ((arg1)->rb);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__random_boolean, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_random_sere(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_sere *arg1 = (spot::random_sere *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_sere, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_random_sere" "', argument " "1"" of type '" "spot::random_sere *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_sere * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *random_sere_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__random_sere, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *random_sere_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_random_psl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::atomic_prop_set *arg1 = (spot::atomic_prop_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::random_psl *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_random_psl" "', argument " "1"" of type '" "spot::atomic_prop_set const *""'"); 
  }
  arg1 = reinterpret_cast< spot::atomic_prop_set * >(argp1);
  {
    try {
      result = (spot::random_psl *)new spot::random_psl((spot::atomic_prop_set const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__random_psl, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_psl_rs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_psl *arg1 = (spot::random_psl *) 0 ;
  spot::random_sere *arg2 = (spot::random_sere *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "random_psl_rs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_psl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_psl_rs_set" "', argument " "1"" of type '" "spot::random_psl *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_psl * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__random_sere, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_psl_rs_set" "', argument " "2"" of type '" "spot::random_sere *""'"); 
  }
  arg2 = reinterpret_cast< spot::random_sere * >(argp2);
  if (arg1) (arg1)->rs = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_psl_rs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_psl *arg1 = (spot::random_psl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::random_sere *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_psl, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "random_psl_rs_get" "', argument " "1"" of type '" "spot::random_psl *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_psl * >(argp1);
  result = (spot::random_sere *)& ((arg1)->rs);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__random_sere, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_random_psl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::random_psl *arg1 = (spot::random_psl *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__random_psl, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_random_psl" "', argument " "1"" of type '" "spot::random_psl *""'"); 
  }
  arg1 = reinterpret_cast< spot::random_psl * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *random_psl_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__random_psl, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *random_psl_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_randltlgenerator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  spot::option_map *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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 ;
  spot::randltlgenerator *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_randltlgenerator" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_randltlgenerator" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_randltlgenerator" "', argument " "4"" of type '" "char *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_randltlgenerator" "', argument " "5"" of type '" "char *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  {
    try {
      result = (spot::randltlgenerator *)new spot::randltlgenerator(arg1,(spot::option_map const &)*arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__randltlgenerator, SWIG_POINTER_NEW |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_randltlgenerator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  spot::option_map *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  spot::randltlgenerator *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_randltlgenerator" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_randltlgenerator" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_randltlgenerator" "', argument " "4"" of type '" "char *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    try {
      result = (spot::randltlgenerator *)new spot::randltlgenerator(arg1,(spot::option_map const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__randltlgenerator, SWIG_POINTER_NEW |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_randltlgenerator__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  spot::option_map *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  spot::randltlgenerator *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_randltlgenerator" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_randltlgenerator" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (spot::randltlgenerator *)new spot::randltlgenerator(arg1,(spot::option_map const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__randltlgenerator, SWIG_POINTER_NEW |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_randltlgenerator__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  spot::option_map *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::randltlgenerator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_randltlgenerator" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  {
    try {
      result = (spot::randltlgenerator *)new spot::randltlgenerator(arg1,(spot::option_map const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__randltlgenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_randltlgenerator__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::atomic_prop_set arg1 ;
  spot::option_map *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  void *argp2 = 0 ;
  int res2 = 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 ;
  spot::randltlgenerator *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *ptr = (std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *)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_randltlgenerator" "', argument " "1"" of type '" "spot::atomic_prop_set""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_randltlgenerator" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_randltlgenerator" "', argument " "4"" of type '" "char *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_randltlgenerator" "', argument " "5"" of type '" "char *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  {
    try {
      result = (spot::randltlgenerator *)new spot::randltlgenerator(arg1,(spot::option_map const &)*arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__randltlgenerator, SWIG_POINTER_NEW |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_randltlgenerator__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::atomic_prop_set arg1 ;
  spot::option_map *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  spot::randltlgenerator *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *ptr = (std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *)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_randltlgenerator" "', argument " "1"" of type '" "spot::atomic_prop_set""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_randltlgenerator" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_randltlgenerator" "', argument " "4"" of type '" "char *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  {
    try {
      result = (spot::randltlgenerator *)new spot::randltlgenerator(arg1,(spot::option_map const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__randltlgenerator, SWIG_POINTER_NEW |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_randltlgenerator__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::atomic_prop_set arg1 ;
  spot::option_map *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  spot::randltlgenerator *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *ptr = (std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *)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_randltlgenerator" "', argument " "1"" of type '" "spot::atomic_prop_set""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_randltlgenerator" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (spot::randltlgenerator *)new spot::randltlgenerator(arg1,(spot::option_map const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__randltlgenerator, SWIG_POINTER_NEW |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_randltlgenerator__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::atomic_prop_set arg1 ;
  spot::option_map *arg2 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::randltlgenerator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *ptr = (std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *)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_randltlgenerator" "', argument " "1"" of type '" "spot::atomic_prop_set""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_randltlgenerator" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  {
    try {
      result = (spot::randltlgenerator *)new spot::randltlgenerator(arg1,(spot::option_map const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__randltlgenerator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_randltlgenerator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_randltlgenerator", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_new_randltlgenerator__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_randltlgenerator__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_new_randltlgenerator__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_randltlgenerator__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_new_randltlgenerator__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_new_randltlgenerator__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_7;
    PyObject *retobj = _wrap_new_randltlgenerator__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_7:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_new_randltlgenerator__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_randltlgenerator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::randltlgenerator::randltlgenerator(int,spot::option_map const &,char *,char *,char *)\n"
    "    spot::randltlgenerator::randltlgenerator(int,spot::option_map const &,char *,char *)\n"
    "    spot::randltlgenerator::randltlgenerator(int,spot::option_map const &,char *)\n"
    "    spot::randltlgenerator::randltlgenerator(int,spot::option_map const &)\n"
    "    spot::randltlgenerator::randltlgenerator(spot::atomic_prop_set,spot::option_map const &,char *,char *,char *)\n"
    "    spot::randltlgenerator::randltlgenerator(spot::atomic_prop_set,spot::option_map const &,char *,char *)\n"
    "    spot::randltlgenerator::randltlgenerator(spot::atomic_prop_set,spot::option_map const &,char *)\n"
    "    spot::randltlgenerator::randltlgenerator(spot::atomic_prop_set,spot::option_map const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_randltlgenerator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::randltlgenerator *arg1 = (spot::randltlgenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__randltlgenerator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_randltlgenerator" "', argument " "1"" of type '" "spot::randltlgenerator *""'"); 
  }
  arg1 = reinterpret_cast< spot::randltlgenerator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randltlgenerator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::randltlgenerator *arg1 = (spot::randltlgenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__randltlgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randltlgenerator_next" "', argument " "1"" of type '" "spot::randltlgenerator *""'"); 
  }
  arg1 = reinterpret_cast< spot::randltlgenerator * >(argp1);
  {
    try {
      result = (arg1)->next();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randltlgenerator_dump_ltl_priorities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::randltlgenerator *arg1 = (spot::randltlgenerator *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "randltlgenerator_dump_ltl_priorities", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__randltlgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randltlgenerator_dump_ltl_priorities" "', argument " "1"" of type '" "spot::randltlgenerator *""'"); 
  }
  arg1 = reinterpret_cast< spot::randltlgenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "randltlgenerator_dump_ltl_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "randltlgenerator_dump_ltl_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      (arg1)->dump_ltl_priorities(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randltlgenerator_dump_bool_priorities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::randltlgenerator *arg1 = (spot::randltlgenerator *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "randltlgenerator_dump_bool_priorities", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__randltlgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randltlgenerator_dump_bool_priorities" "', argument " "1"" of type '" "spot::randltlgenerator *""'"); 
  }
  arg1 = reinterpret_cast< spot::randltlgenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "randltlgenerator_dump_bool_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "randltlgenerator_dump_bool_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      (arg1)->dump_bool_priorities(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randltlgenerator_dump_psl_priorities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::randltlgenerator *arg1 = (spot::randltlgenerator *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "randltlgenerator_dump_psl_priorities", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__randltlgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randltlgenerator_dump_psl_priorities" "', argument " "1"" of type '" "spot::randltlgenerator *""'"); 
  }
  arg1 = reinterpret_cast< spot::randltlgenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "randltlgenerator_dump_psl_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "randltlgenerator_dump_psl_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      (arg1)->dump_psl_priorities(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randltlgenerator_dump_sere_priorities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::randltlgenerator *arg1 = (spot::randltlgenerator *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "randltlgenerator_dump_sere_priorities", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__randltlgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randltlgenerator_dump_sere_priorities" "', argument " "1"" of type '" "spot::randltlgenerator *""'"); 
  }
  arg1 = reinterpret_cast< spot::randltlgenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "randltlgenerator_dump_sere_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "randltlgenerator_dump_sere_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      (arg1)->dump_sere_priorities(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randltlgenerator_dump_sere_bool_priorities(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::randltlgenerator *arg1 = (spot::randltlgenerator *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "randltlgenerator_dump_sere_bool_priorities", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__randltlgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randltlgenerator_dump_sere_bool_priorities" "', argument " "1"" of type '" "spot::randltlgenerator *""'"); 
  }
  arg1 = reinterpret_cast< spot::randltlgenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "randltlgenerator_dump_sere_bool_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "randltlgenerator_dump_sere_bool_priorities" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      (arg1)->dump_sere_bool_priorities(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randltlgenerator_remove_some_props(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::randltlgenerator *arg1 = (spot::randltlgenerator *) 0 ;
  spot::atomic_prop_set *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "randltlgenerator_remove_some_props", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__randltlgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randltlgenerator_remove_some_props" "', argument " "1"" of type '" "spot::randltlgenerator *""'"); 
  }
  arg1 = reinterpret_cast< spot::randltlgenerator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "randltlgenerator_remove_some_props" "', argument " "2"" of type '" "spot::atomic_prop_set &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "randltlgenerator_remove_some_props" "', argument " "2"" of type '" "spot::atomic_prop_set &""'"); 
  }
  arg2 = reinterpret_cast< spot::atomic_prop_set * >(argp2);
  {
    try {
      (arg1)->remove_some_props(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randltlgenerator_GF_n(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::randltlgenerator *arg1 = (spot::randltlgenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__randltlgenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randltlgenerator_GF_n" "', argument " "1"" of type '" "spot::randltlgenerator *""'"); 
  }
  arg1 = reinterpret_cast< spot::randltlgenerator * >(argp1);
  {
    try {
      result = (arg1)->GF_n();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *randltlgenerator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__randltlgenerator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *randltlgenerator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_length(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "length" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = (int)spot::length(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_length_boolone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "length_boolone" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = (int)spot::length_boolone(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_from_ltlf__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "from_ltlf" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "from_ltlf" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::from_ltlf(SWIG_STD_MOVE(arg1),(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_from_ltlf__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::formula result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "from_ltlf" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::from_ltlf(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_from_ltlf(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "from_ltlf", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_from_ltlf__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_from_ltlf__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'from_ltlf'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::from_ltlf(spot::formula,char const *)\n"
    "    spot::from_ltlf(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_persistence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::twa_graph_ptr arg2 ;
  spot::prcheck arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_persistence" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_persistence" "', argument " "2"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "is_persistence" "', argument " "3"" of type '" "spot::prcheck""'");
  } 
  arg3 = static_cast< spot::prcheck >(val3);
  {
    try {
      result = (bool)spot::is_persistence(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_persistence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::twa_graph_ptr arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_persistence" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_persistence" "', argument " "2"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::is_persistence(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_persistence__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_persistence" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = (bool)spot::is_persistence(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_persistence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_persistence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_is_persistence__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_is_persistence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_is_persistence__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_persistence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_persistence(spot::formula,spot::twa_graph_ptr,spot::prcheck)\n"
    "    spot::is_persistence(spot::formula,spot::twa_graph_ptr)\n"
    "    spot::is_persistence(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_recurrence__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::twa_graph_ptr arg2 ;
  spot::prcheck arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_recurrence" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_recurrence" "', argument " "2"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "is_recurrence" "', argument " "3"" of type '" "spot::prcheck""'");
  } 
  arg3 = static_cast< spot::prcheck >(val3);
  {
    try {
      result = (bool)spot::is_recurrence(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_recurrence__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::twa_graph_ptr arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_recurrence" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_recurrence" "', argument " "2"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::is_recurrence(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_recurrence__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_recurrence" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = (bool)spot::is_recurrence(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_recurrence(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_recurrence", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_is_recurrence__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_is_recurrence__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_is_recurrence__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_recurrence'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_recurrence(spot::formula,spot::twa_graph_ptr,spot::prcheck)\n"
    "    spot::is_recurrence(spot::formula,spot::twa_graph_ptr)\n"
    "    spot::is_recurrence(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_obligation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::twa_graph_ptr arg2 ;
  spot::ocheck arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_obligation" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_obligation" "', argument " "2"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "is_obligation" "', argument " "3"" of type '" "spot::ocheck""'");
  } 
  arg3 = static_cast< spot::ocheck >(val3);
  {
    try {
      result = (bool)spot::is_obligation(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_obligation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::twa_graph_ptr arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_obligation" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_obligation" "', argument " "2"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::is_obligation(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_obligation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_obligation" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = (bool)spot::is_obligation(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_obligation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_obligation", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_is_obligation__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_is_obligation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_is_obligation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_obligation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_obligation(spot::formula,spot::twa_graph_ptr,spot::ocheck)\n"
    "    spot::is_obligation(spot::formula,spot::twa_graph_ptr)\n"
    "    spot::is_obligation(spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_mp_class__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  char result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "mp_class" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = (char)spot::mp_class(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mp_class__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "mp_class" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mp_class" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::mp_class(SWIG_STD_MOVE(arg1),(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_mp_class__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char arg1 ;
  char *arg2 = (char *) 0 ;
  char val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mp_class" "', argument " "1"" of type '" "char""'");
  } 
  arg1 = static_cast< char >(val1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mp_class" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::mp_class(arg1,(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_mp_class(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "mp_class", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_mp_class__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_char(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    PyObject *retobj = _wrap_mp_class__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_mp_class__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'mp_class'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::mp_class(spot::formula)\n"
    "    spot::mp_class(spot::formula,char const *)\n"
    "    spot::mp_class(char,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_nesting_depth__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::op arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "nesting_depth" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nesting_depth" "', argument " "2"" of type '" "spot::op""'");
  } 
  arg2 = static_cast< spot::op >(val2);
  {
    try {
      result = (unsigned int)spot::nesting_depth(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nesting_depth__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "nesting_depth" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nesting_depth" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (unsigned int)spot::nesting_depth(SWIG_STD_MOVE(arg1),(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_nesting_depth(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "nesting_depth", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    return _wrap_nesting_depth__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_nesting_depth__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'nesting_depth'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::nesting_depth(spot::formula,spot::op)\n"
    "    spot::nesting_depth(spot::formula,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_liveness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_liveness" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = (bool)spot::is_liveness(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_x(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  PyObject *swig_obj[1] ;
  spot::formula result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "remove_x" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = spot::remove_x(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabel__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::relabeling_style arg2 ;
  spot::relabeling_map *arg3 = (spot::relabeling_map *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "relabel" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "relabel" "', argument " "2"" of type '" "spot::relabeling_style""'");
  } 
  arg2 = static_cast< spot::relabeling_style >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "relabel" "', argument " "3"" of type '" "spot::relabeling_map *""'"); 
  }
  arg3 = reinterpret_cast< spot::relabeling_map * >(argp3);
  {
    try {
      result = spot::relabel(SWIG_STD_MOVE(arg1),arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabel__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::relabeling_style arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "relabel" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "relabel" "', argument " "2"" of type '" "spot::relabeling_style""'");
  } 
  arg2 = static_cast< spot::relabeling_style >(val2);
  {
    try {
      result = spot::relabel(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabel(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "relabel", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_relabel__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_relabel__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'relabel'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::relabel(spot::formula,spot::relabeling_style,spot::relabeling_map *)\n"
    "    spot::relabel(spot::formula,spot::relabeling_style)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_relabel_bse__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::relabeling_style arg2 ;
  spot::relabeling_map *arg3 = (spot::relabeling_map *) 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::formula result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "relabel_bse" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "relabel_bse" "', argument " "2"" of type '" "spot::relabeling_style""'");
  } 
  arg2 = static_cast< spot::relabeling_style >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "relabel_bse" "', argument " "3"" of type '" "spot::relabeling_map *""'"); 
  }
  arg3 = reinterpret_cast< spot::relabeling_map * >(argp3);
  {
    try {
      result = spot::relabel_bse(SWIG_STD_MOVE(arg1),arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabel_bse__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::relabeling_style arg2 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::formula result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "relabel_bse" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "relabel_bse" "', argument " "2"" of type '" "spot::relabeling_style""'");
  } 
  arg2 = static_cast< spot::relabeling_style >(val2);
  {
    try {
      result = spot::relabel_bse(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_relabel_bse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "relabel_bse", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_relabel_bse__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_relabel_bse__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'relabel_bse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::relabel_bse(spot::formula,spot::relabeling_style,spot::relabeling_map *)\n"
    "    spot::relabel_bse(spot::formula,spot::relabeling_style)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_relabel_apply(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::relabeling_map *arg2 = (spot::relabeling_map *) 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::formula result;
  
  if (!SWIG_Python_UnpackTuple(args, "relabel_apply", 2, 2, swig_obj)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "relabel_apply" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabel_apply" "', argument " "2"" of type '" "spot::relabeling_map *""'"); 
  }
  arg2 = reinterpret_cast< spot::relabeling_map * >(argp2);
  {
    try {
      result = spot::relabel_apply(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    if (!result)
    resultobj = SWIG_Py_Void();
    else
    resultobj = SWIG_NewPointerObj(new spot::formula(result), SWIGTYPE_p_spot__formula, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_taa_tgba_add_condition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::taa_tgba *arg1 = (spot::taa_tgba *) 0 ;
  spot::taa_tgba::transition *arg2 = (spot::taa_tgba::transition *) 0 ;
  spot::formula arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::taa_tgba > tempshared1 ;
  std::shared_ptr< spot::taa_tgba > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "taa_tgba_add_condition", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "taa_tgba_add_condition" "', argument " "1"" of type '" "spot::taa_tgba *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::taa_tgba > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::taa_tgba > * >(argp1);
      arg1 = const_cast< spot::taa_tgba * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::taa_tgba > * >(argp1);
      arg1 = const_cast< spot::taa_tgba * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__taa_tgba__transition, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "taa_tgba_add_condition" "', argument " "2"" of type '" "spot::taa_tgba::transition *""'"); 
  }
  arg2 = reinterpret_cast< spot::taa_tgba::transition * >(argp2);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "taa_tgba_add_condition" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  {
    try {
      (arg1)->add_condition(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_taa_tgba(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::taa_tgba *arg1 = (spot::taa_tgba *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::taa_tgba > tempshared1 ;
  std::shared_ptr< spot::taa_tgba > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_taa_tgba" "', argument " "1"" of type '" "spot::taa_tgba *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::taa_tgba > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::taa_tgba > * >(argp1);
      arg1 = const_cast< spot::taa_tgba * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::taa_tgba > * >(argp1);
      arg1 = const_cast< spot::taa_tgba * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_taa_tgba_get_init_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::taa_tgba *arg1 = (spot::taa_tgba *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::taa_tgba const > tempshared1 ;
  std::shared_ptr< spot::taa_tgba const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "taa_tgba_get_init_state" "', argument " "1"" of type '" "spot::taa_tgba const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::taa_tgba > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::taa_tgba > * >(argp1);
      arg1 = const_cast< spot::taa_tgba * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::taa_tgba > * >(argp1);
      arg1 = const_cast< spot::taa_tgba * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::state *)((spot::taa_tgba const *)arg1)->get_init_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *taa_tgba_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_set_state__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::taa_tgba::state_set *arg1 = (spot::taa_tgba::state_set *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::set_state *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_set_state" "', argument " "1"" of type '" "spot::taa_tgba::state_set const *""'"); 
  }
  arg1 = reinterpret_cast< spot::taa_tgba::state_set * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_set_state" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (spot::set_state *)new spot::set_state((spot::taa_tgba::state_set const *)arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__set_state, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_set_state__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::taa_tgba::state_set *arg1 = (spot::taa_tgba::state_set *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::set_state *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_set_state" "', argument " "1"" of type '" "spot::taa_tgba::state_set const *""'"); 
  }
  arg1 = reinterpret_cast< spot::taa_tgba::state_set * >(argp1);
  {
    try {
      result = (spot::set_state *)new spot::set_state((spot::taa_tgba::state_set const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__set_state, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_set_state(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_set_state", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_set_state__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_set_state__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_set_state'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::set_state::set_state(spot::taa_tgba::state_set const *,bool)\n"
    "    spot::set_state::set_state(spot::taa_tgba::state_set const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_set_state_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::set_state *arg1 = (spot::set_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::set_state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__set_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_state_clone" "', argument " "1"" of type '" "spot::set_state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::set_state * >(argp1);
  {
    try {
      result = (spot::set_state *)((spot::set_state const *)arg1)->clone();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__set_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_set_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::set_state *arg1 = (spot::set_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__set_state, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_set_state" "', argument " "1"" of type '" "spot::set_state *""'"); 
  }
  arg1 = reinterpret_cast< spot::set_state * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_state_get_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::set_state *arg1 = (spot::set_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::taa_tgba::state_set *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__set_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_state_get_state" "', argument " "1"" of type '" "spot::set_state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::set_state * >(argp1);
  {
    try {
      result = (spot::taa_tgba::state_set *)((spot::set_state const *)arg1)->get_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *set_state_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__set_state, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *set_state_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_taa_succ_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::taa_tgba::state_set *arg1 = (spot::taa_tgba::state_set *) 0 ;
  spot::acc_cond *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::taa_succ_iterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_taa_succ_iterator", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_taa_succ_iterator" "', argument " "1"" of type '" "spot::taa_tgba::state_set const *""'"); 
  }
  arg1 = reinterpret_cast< spot::taa_tgba::state_set * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_taa_succ_iterator" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_taa_succ_iterator" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond * >(argp2);
  {
    try {
      result = (spot::taa_succ_iterator *)new spot::taa_succ_iterator((spot::taa_tgba::state_set const *)arg1,(spot::acc_cond const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__taa_succ_iterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_taa_succ_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::taa_succ_iterator *arg1 = (spot::taa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__taa_succ_iterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_taa_succ_iterator" "', argument " "1"" of type '" "spot::taa_succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::taa_succ_iterator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_taa_succ_iterator_dst(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::taa_succ_iterator *arg1 = (spot::taa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::set_state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__taa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "taa_succ_iterator_dst" "', argument " "1"" of type '" "spot::taa_succ_iterator const *""'"); 
  }
  arg1 = reinterpret_cast< spot::taa_succ_iterator * >(argp1);
  {
    try {
      result = (spot::set_state *)((spot::taa_succ_iterator const *)arg1)->dst();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__set_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *taa_succ_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__taa_succ_iterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *taa_succ_iterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_taa_tgba_string(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::taa_tgba_string *arg1 = (spot::taa_tgba_string *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::taa_tgba_string > tempshared1 ;
  std::shared_ptr< spot::taa_tgba_string > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_string_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_taa_tgba_string" "', argument " "1"" of type '" "spot::taa_tgba_string *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::taa_tgba_string > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::taa_tgba_string > * >(argp1);
      arg1 = const_cast< spot::taa_tgba_string * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::taa_tgba_string > * >(argp1);
      arg1 = const_cast< spot::taa_tgba_string * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *taa_tgba_string_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_string_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_make_taa_tgba_string(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::taa_tgba_string_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_taa_tgba_string" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::make_taa_tgba_string((std::shared_ptr< spot::bdd_dict > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::taa_tgba_string > *smartresult = result ? new std::shared_ptr<  spot::taa_tgba_string >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_string_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_taa_tgba_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::taa_tgba_formula *arg1 = (spot::taa_tgba_formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::taa_tgba_formula > tempshared1 ;
  std::shared_ptr< spot::taa_tgba_formula > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_formula_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_taa_tgba_formula" "', argument " "1"" of type '" "spot::taa_tgba_formula *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::taa_tgba_formula > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::taa_tgba_formula > * >(argp1);
      arg1 = const_cast< spot::taa_tgba_formula * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::taa_tgba_formula > * >(argp1);
      arg1 = const_cast< spot::taa_tgba_formula * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *taa_tgba_formula_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_formula_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_make_taa_tgba_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::taa_tgba_formula_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_taa_tgba_formula" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::make_taa_tgba_formula((std::shared_ptr< spot::bdd_dict > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::taa_tgba_formula > *smartresult = result ? new std::shared_ptr<  spot::taa_tgba_formula >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_formula_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_state_product(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state *arg1 = (spot::state *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  fixed_size_pool< pool_type::Safe > *arg3 = (fixed_size_pool< pool_type::Safe > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::state_product *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_state_product", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_state_product" "', argument " "1"" of type '" "spot::state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_state_product" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_fixed_size_poolT_pool_type__Safe_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_state_product" "', argument " "3"" of type '" "fixed_size_pool< pool_type::Safe > *""'"); 
  }
  arg3 = reinterpret_cast< fixed_size_pool< pool_type::Safe > * >(argp3);
  {
    try {
      result = (spot::state_product *)new spot::state_product((spot::state const *)arg1,(spot::state const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state_product, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_state_product_left(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_product *arg1 = (spot::state_product *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_product, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_product_left" "', argument " "1"" of type '" "spot::state_product const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_product * >(argp1);
  {
    try {
      result = (spot::state *)((spot::state_product const *)arg1)->left();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_state_product_right(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_product *arg1 = (spot::state_product *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_product, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_product_right" "', argument " "1"" of type '" "spot::state_product const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_product * >(argp1);
  {
    try {
      result = (spot::state *)((spot::state_product const *)arg1)->right();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_state_product_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_product *arg1 = (spot::state_product *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state_product *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_product, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "state_product_clone" "', argument " "1"" of type '" "spot::state_product const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_product * >(argp1);
  {
    try {
      result = (spot::state_product *)((spot::state_product const *)arg1)->clone();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state_product, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *state_product_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__state_product, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *state_product_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_twa_product(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  spot::twa_product *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_twa_product", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_product" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_twa_product" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (spot::twa_product *)new spot::twa_product((spot::const_twa_ptr const &)*arg1,(spot::const_twa_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_product > *smartresult = result ? new std::shared_ptr<  spot::twa_product >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_product_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_twa_product(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_product *arg1 = (spot::twa_product *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_product > tempshared1 ;
  std::shared_ptr< spot::twa_product > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_product_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_product" "', argument " "1"" of type '" "spot::twa_product *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_product > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_product > * >(argp1);
      arg1 = const_cast< spot::twa_product * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_product > * >(argp1);
      arg1 = const_cast< spot::twa_product * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_product_left_acc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_product *arg1 = (spot::twa_product *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_product const > tempshared1 ;
  std::shared_ptr< spot::twa_product const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_product_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_product_left_acc" "', argument " "1"" of type '" "spot::twa_product const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_product > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_product > * >(argp1);
      arg1 = const_cast< spot::twa_product * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_product > * >(argp1);
      arg1 = const_cast< spot::twa_product * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::acc_cond *) &((spot::twa_product const *)arg1)->left_acc();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_product_right_acc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_product *arg1 = (spot::twa_product *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_product const > tempshared1 ;
  std::shared_ptr< spot::twa_product const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_product_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_product_right_acc" "', argument " "1"" of type '" "spot::twa_product const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_product > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_product > * >(argp1);
      arg1 = const_cast< spot::twa_product * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_product > * >(argp1);
      arg1 = const_cast< spot::twa_product * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::acc_cond *) &((spot::twa_product const *)arg1)->right_acc();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_product_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__twa_product_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_product_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_twa_product_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  spot::state *arg3 = (spot::state *) 0 ;
  spot::state *arg4 = (spot::state *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  spot::twa_product_init *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_twa_product_init", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_product_init" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_twa_product_init" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_twa_product_init" "', argument " "3"" of type '" "spot::state const *""'"); 
  }
  arg3 = reinterpret_cast< spot::state * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_twa_product_init" "', argument " "4"" of type '" "spot::state const *""'"); 
  }
  arg4 = reinterpret_cast< spot::state * >(argp4);
  {
    try {
      result = (spot::twa_product_init *)new spot::twa_product_init((spot::const_twa_ptr const &)*arg1,(spot::const_twa_ptr const &)*arg2,(spot::state const *)arg3,(spot::state const *)arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_product_init > *smartresult = result ? new std::shared_ptr<  spot::twa_product_init >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_product_init_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_twa_product_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_product_init *arg1 = (spot::twa_product_init *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_product_init > tempshared1 ;
  std::shared_ptr< spot::twa_product_init > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_product_init_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_product_init" "', argument " "1"" of type '" "spot::twa_product_init *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_product_init > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_product_init > * >(argp1);
      arg1 = const_cast< spot::twa_product_init * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_product_init > * >(argp1);
      arg1 = const_cast< spot::twa_product_init * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_product_init_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__twa_product_init_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_product_init_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_otf_product(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  spot::twa_product_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "otf_product", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "otf_product" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "otf_product" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::otf_product((std::shared_ptr< spot::twa const > const &)*arg1,(std::shared_ptr< spot::twa const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_product > *smartresult = result ? new std::shared_ptr<  spot::twa_product >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_product_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_otf_product_at(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  spot::state *arg3 = (spot::state *) 0 ;
  spot::state *arg4 = (spot::state *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  spot::twa_product_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "otf_product_at", 4, 4, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "otf_product_at" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "otf_product_at" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "otf_product_at" "', argument " "3"" of type '" "spot::state const *""'"); 
  }
  arg3 = reinterpret_cast< spot::state * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "otf_product_at" "', argument " "4"" of type '" "spot::state const *""'"); 
  }
  arg4 = reinterpret_cast< spot::state * >(argp4);
  {
    try {
      result = spot::otf_product_at((std::shared_ptr< spot::twa const > const &)*arg1,(std::shared_ptr< spot::twa const > const &)*arg2,(spot::state const *)arg3,(spot::state const *)arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_product > *smartresult = result ? new std::shared_ptr<  spot::twa_product >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_product_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_const_universal_dests__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int *arg1 = (unsigned int *) 0 ;
  unsigned int *arg2 = (unsigned int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::internal::const_universal_dests *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_const_universal_dests" "', argument " "1"" of type '" "unsigned int const *""'"); 
  }
  arg1 = reinterpret_cast< unsigned int * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_const_universal_dests" "', argument " "2"" of type '" "unsigned int const *""'"); 
  }
  arg2 = reinterpret_cast< unsigned int * >(argp2);
  {
    try {
      result = (spot::internal::const_universal_dests *)new spot::internal::const_universal_dests((unsigned int const *)arg1,(unsigned int const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__const_universal_dests, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_const_universal_dests__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  spot::internal::const_universal_dests *result = 0 ;
  
  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 '" "new_const_universal_dests" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = (spot::internal::const_universal_dests *)new spot::internal::const_universal_dests(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__const_universal_dests, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_const_universal_dests(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_const_universal_dests", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_const_universal_dests__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_const_universal_dests__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_const_universal_dests'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::internal::const_universal_dests::const_universal_dests(unsigned int const *,unsigned int const *)\n"
    "    spot::internal::const_universal_dests::const_universal_dests(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_const_universal_dests_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::const_universal_dests *arg1 = (spot::internal::const_universal_dests *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__const_universal_dests, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "const_universal_dests_begin" "', argument " "1"" of type '" "spot::internal::const_universal_dests const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::const_universal_dests * >(argp1);
  {
    try {
      result = (unsigned int *)((spot::internal::const_universal_dests const *)arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_const_universal_dests_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::const_universal_dests *arg1 = (spot::internal::const_universal_dests *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__const_universal_dests, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "const_universal_dests_end" "', argument " "1"" of type '" "spot::internal::const_universal_dests const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::const_universal_dests * >(argp1);
  {
    try {
      result = (unsigned int *)((spot::internal::const_universal_dests const *)arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_const_universal_dests___iter__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::const_universal_dests *arg1 = (spot::internal::const_universal_dests *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__const_universal_dests, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "const_universal_dests___iter__" "', argument " "1"" of type '" "spot::internal::const_universal_dests *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::const_universal_dests * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)spot_internal_const_universal_dests___iter__(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_const_universal_dests(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::const_universal_dests *arg1 = (spot::internal::const_universal_dests *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__const_universal_dests, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_const_universal_dests" "', argument " "1"" of type '" "spot::internal::const_universal_dests *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::const_universal_dests * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *const_universal_dests_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__const_universal_dests, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *const_universal_dests_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_twa_graph_state__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::twa_graph_state *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::twa_graph_state *)new spot::twa_graph_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_state, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_graph_state__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_state *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::twa_graph_state *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__twa_graph_state,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_graph_state" "', argument " "1"" of type '" "spot::twa_graph_state const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_twa_graph_state" "', argument " "1"" of type '" "spot::twa_graph_state const &""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph_state * >(argp1);
  {
    try {
      result = (spot::twa_graph_state *)new spot::twa_graph_state((spot::twa_graph_state const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_state, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_graph_state(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_twa_graph_state", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_twa_graph_state__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_twa_graph_state__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_twa_graph_state'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph_state::twa_graph_state()\n"
    "    spot::twa_graph_state::twa_graph_state(spot::twa_graph_state const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_twa_graph_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_state *arg1 = (spot::twa_graph_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_graph_state, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_graph_state" "', argument " "1"" of type '" "spot::twa_graph_state *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph_state * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_state *arg1 = (spot::twa_graph_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_graph_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_state_clone" "', argument " "1"" of type '" "spot::twa_graph_state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph_state * >(argp1);
  {
    try {
      result = (spot::twa_graph_state *)((spot::twa_graph_state const *)arg1)->clone();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_graph_state_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__twa_graph_state, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_graph_state_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_twa_graph_edge_data_cond_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_edge_data *arg1 = (spot::twa_graph_edge_data *) 0 ;
  bdd *arg2 = (bdd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_edge_data_cond_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_data_cond_set" "', argument " "1"" of type '" "spot::twa_graph_edge_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph_edge_data * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_bdd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_data_cond_set" "', argument " "2"" of type '" "bdd *""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  if (arg1) (arg1)->cond = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_data_cond_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_edge_data *arg1 = (spot::twa_graph_edge_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bdd *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_data_cond_get" "', argument " "1"" of type '" "spot::twa_graph_edge_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph_edge_data * >(argp1);
  result = (bdd *)& ((arg1)->cond);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bdd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_data_acc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_edge_data *arg1 = (spot::twa_graph_edge_data *) 0 ;
  spot::acc_cond::mark_t *arg2 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_edge_data_acc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_data_acc_set" "', argument " "1"" of type '" "spot::twa_graph_edge_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph_edge_data * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_data_acc_set" "', argument " "2"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
  if (arg1) (arg1)->acc = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_data_acc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_edge_data *arg1 = (spot::twa_graph_edge_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_data_acc_get" "', argument " "1"" of type '" "spot::twa_graph_edge_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph_edge_data * >(argp1);
  result = (spot::acc_cond::mark_t *)& ((arg1)->acc);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_graph_edge_data__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::twa_graph_edge_data *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::twa_graph_edge_data *)new spot::twa_graph_edge_data();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_edge_data, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_graph_edge_data__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bdd arg1 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_edge_data *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_graph_edge_data" "', argument " "1"" of type '" "bdd""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_twa_graph_edge_data" "', argument " "1"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_twa_graph_edge_data" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_twa_graph_edge_data" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::twa_graph_edge_data *)new spot::twa_graph_edge_data(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_edge_data, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_graph_edge_data__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bdd arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_edge_data *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_graph_edge_data" "', argument " "1"" of type '" "bdd""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_twa_graph_edge_data" "', argument " "1"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = (spot::twa_graph_edge_data *)new spot::twa_graph_edge_data(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_edge_data, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_graph_edge_data(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_twa_graph_edge_data", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_twa_graph_edge_data__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_twa_graph_edge_data__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_twa_graph_edge_data__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_twa_graph_edge_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph_edge_data::twa_graph_edge_data()\n"
    "    spot::twa_graph_edge_data::twa_graph_edge_data(bdd,spot::acc_cond::mark_t)\n"
    "    spot::twa_graph_edge_data::twa_graph_edge_data(bdd)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_data___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_edge_data *arg1 = (spot::twa_graph_edge_data *) 0 ;
  spot::twa_graph_edge_data *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_edge_data___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_data___lt__" "', argument " "1"" of type '" "spot::twa_graph_edge_data const *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph_edge_data * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa_graph_edge_data,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_data___lt__" "', argument " "2"" of type '" "spot::twa_graph_edge_data const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_edge_data___lt__" "', argument " "2"" of type '" "spot::twa_graph_edge_data const &""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_graph_edge_data * >(argp2);
  {
    try {
      result = (bool)((spot::twa_graph_edge_data const *)arg1)->operator <((spot::twa_graph_edge_data const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_data___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_edge_data *arg1 = (spot::twa_graph_edge_data *) 0 ;
  spot::twa_graph_edge_data *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_edge_data___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_data___eq__" "', argument " "1"" of type '" "spot::twa_graph_edge_data const *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph_edge_data * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa_graph_edge_data,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_data___eq__" "', argument " "2"" of type '" "spot::twa_graph_edge_data const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_edge_data___eq__" "', argument " "2"" of type '" "spot::twa_graph_edge_data const &""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_graph_edge_data * >(argp2);
  {
    try {
      result = (bool)((spot::twa_graph_edge_data const *)arg1)->operator ==((spot::twa_graph_edge_data const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_twa_graph_edge_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_edge_data *arg1 = (spot::twa_graph_edge_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_graph_edge_data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_graph_edge_data" "', argument " "1"" of type '" "spot::twa_graph_edge_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph_edge_data * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_graph_edge_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__twa_graph_edge_data, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_graph_edge_data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_twa_graph_apply_permutation(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_apply_permutation", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_apply_permutation" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    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 '" "twa_graph_apply_permutation" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      (arg1)->apply_permutation(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_graph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  spot::twa_graph *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_graph" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::twa_graph *)new spot::twa_graph((spot::bdd_dict_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_graph__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::twa::prop_set arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_graph" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::twa_graph *)new spot::twa_graph((spot::const_twa_graph_ptr const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_graph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_twa_graph", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_twa_graph__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_twa_graph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_twa_graph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::twa_graph(spot::bdd_dict_ptr const &)\n"
    "    spot::twa_graph::twa_graph(spot::const_twa_graph_ptr const &,spot::twa::prop_set)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_twa_graph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_graph" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_get_graph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  spot::twa_graph::graph_t *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_get_graph" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::twa_graph::graph_t *) &(arg1)->get_graph();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_get_graph__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  spot::twa_graph::graph_t *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_get_graph" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::twa_graph::graph_t *) &((spot::twa_graph const *)arg1)->get_graph();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_get_graph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_get_graph", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_graph_get_graph__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_graph_get_graph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_get_graph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::get_graph()\n"
    "    spot::twa_graph::get_graph() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_num_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_num_states" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::twa_graph const *)arg1)->num_states();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_num_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_num_edges" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::twa_graph const *)arg1)->num_edges();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_set_init_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_graph::state_num arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_set_init_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_set_init_state" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_set_init_state" "', argument " "2"" of type '" "spot::twa_graph::state_num""'");
  } 
  arg2 = static_cast< spot::twa_graph::state_num >(val2);
  {
    try {
      (arg1)->set_init_state(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_set_univ_init_state__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  std::initializer_list< spot::twa_graph::state_num > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_set_univ_init_state" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__initializer_listT_unsigned_int_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_set_univ_init_state" "', argument " "2"" of type '" "std::initializer_list< spot::twa_graph::state_num > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_set_univ_init_state" "', argument " "2"" of type '" "std::initializer_list< spot::twa_graph::state_num > const &""'"); 
  }
  arg2 = reinterpret_cast< std::initializer_list< spot::twa_graph::state_num > * >(argp2);
  {
    try {
      (arg1)->set_univ_init_state((std::initializer_list< spot::twa_graph::state_num > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_get_init_state_number(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph::state_num result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_get_init_state_number" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::twa_graph::state_num)((spot::twa_graph const *)arg1)->get_init_state_number();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_get_init_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_get_init_state" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::twa_graph_state *)((spot::twa_graph const *)arg1)->get_init_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_is_univ_dest__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph::edge_storage_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_is_univ_dest" "', argument " "1"" of type '" "spot::twa_graph::edge_storage_t const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_is_univ_dest" "', argument " "1"" of type '" "spot::twa_graph::edge_storage_t const &""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_graph::edge_storage_t * >(argp1);
  {
    try {
      result = (bool)spot::twa_graph::is_univ_dest((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_is_univ_dest__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  bool result;
  
  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 '" "twa_graph_is_univ_dest" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = (bool)spot::twa_graph::is_univ_dest(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_is_univ_dest(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_is_univ_dest", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_twa_graph_is_univ_dest__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_graph_is_univ_dest__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_is_univ_dest'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::is_univ_dest(spot::twa_graph::edge_storage_t const &)\n"
    "    spot::twa_graph::is_univ_dest(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_number(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::twa_graph::state_num result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_state_number", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_state_number" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_state_number" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (spot::twa_graph::state_num)((spot::twa_graph const *)arg1)->state_number((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_from_number(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_graph::state_num arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::twa_graph_state *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_state_from_number", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_state_from_number" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_state_from_number" "', argument " "2"" of type '" "spot::twa_graph::state_num""'");
  } 
  arg2 = static_cast< spot::twa_graph::state_num >(val2);
  {
    try {
      result = (spot::twa_graph_state *)((spot::twa_graph const *)arg1)->state_from_number(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_format_state__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_format_state" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_format_state" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::twa_graph const *)arg1)->format_state(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_format_state__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_format_state" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_format_state" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = ((spot::twa_graph const *)arg1)->format_state((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_format_state(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_format_state", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__state, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_twa_graph_format_state__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_format_state__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_format_state'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::format_state(unsigned int) const\n"
    "    spot::twa_graph::format_state(spot::state const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_number__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_succ_iterator *arg2 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_number" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_number" "', argument " "2"" of type '" "spot::twa_succ_iterator const *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_succ_iterator * >(argp2);
  {
    try {
      result = (unsigned int)((spot::twa_graph const *)arg1)->edge_number((spot::twa_succ_iterator const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_number__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_graph::edge_storage_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_number" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_number" "', argument " "2"" of type '" "spot::twa_graph::edge_storage_t const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_edge_number" "', argument " "2"" of type '" "spot::twa_graph::edge_storage_t const &""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_graph::edge_storage_t * >(argp2);
  {
    try {
      result = (unsigned int)((spot::twa_graph const *)arg1)->edge_number((spot::twa_graph::edge_storage_t const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_number(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_edge_number", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__twa_succ_iterator, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_twa_graph_edge_number__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_edge_number__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_edge_number'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::edge_number(spot::twa_succ_iterator const *) const\n"
    "    spot::twa_graph::edge_number(spot::twa_graph::edge_storage_t const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_data__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_succ_iterator *arg2 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_edge_data *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_data" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_data" "', argument " "2"" of type '" "spot::twa_succ_iterator const *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_succ_iterator * >(argp2);
  {
    try {
      result = (spot::twa_graph_edge_data *) &(arg1)->edge_data((spot::twa_succ_iterator const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_data__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_edge_data *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_data" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_edge_data" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::twa_graph_edge_data *) &(arg1)->edge_data(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_data__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_succ_iterator *arg2 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_edge_data *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_data" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_data" "', argument " "2"" of type '" "spot::twa_succ_iterator const *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_succ_iterator * >(argp2);
  {
    try {
      result = (spot::twa_graph_edge_data *) &((spot::twa_graph const *)arg1)->edge_data((spot::twa_succ_iterator const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_data__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_edge_data *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_data" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_edge_data" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::twa_graph_edge_data *) &((spot::twa_graph const *)arg1)->edge_data(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_data(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_edge_data", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__twa_succ_iterator, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_twa_graph_edge_data__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__twa_succ_iterator, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_twa_graph_edge_data__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_edge_data__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_edge_data__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_edge_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::edge_data(spot::twa_succ_iterator const *)\n"
    "    spot::twa_graph::edge_data(unsigned int)\n"
    "    spot::twa_graph::edge_data(spot::twa_succ_iterator const *) const\n"
    "    spot::twa_graph::edge_data(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_succ_iterator *arg2 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph::edge_storage_t *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_storage" "', argument " "2"" of type '" "spot::twa_succ_iterator const *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_succ_iterator * >(argp2);
  {
    try {
      result = (spot::twa_graph::edge_storage_t *) &(arg1)->edge_storage((spot::twa_succ_iterator const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph::edge_storage_t *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_edge_storage" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::twa_graph::edge_storage_t *) &(arg1)->edge_storage(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_succ_iterator *arg2 = (spot::twa_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph::edge_storage_t result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_storage" "', argument " "2"" of type '" "spot::twa_succ_iterator const *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_succ_iterator * >(argp2);
  {
    try {
      result = ((spot::twa_graph const *)arg1)->edge_storage((spot::twa_succ_iterator const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::twa_graph::edge_storage_t(result)), SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph::edge_storage_t result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_edge_storage" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::twa_graph const *)arg1)->edge_storage(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::twa_graph::edge_storage_t(result)), SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_edge_storage", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__twa_succ_iterator, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_twa_graph_edge_storage__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__twa_succ_iterator, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_twa_graph_edge_storage__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_edge_storage__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_edge_storage__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_edge_storage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::edge_storage(spot::twa_succ_iterator const *)\n"
    "    spot::twa_graph::edge_storage(unsigned int)\n"
    "    spot::twa_graph::edge_storage(spot::twa_succ_iterator const *) const\n"
    "    spot::twa_graph::edge_storage(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_new_state" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->new_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_new_states", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_new_states" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_new_states" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)(arg1)->new_states(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_edge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  bdd arg4 ;
  spot::acc_cond::mark_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  unsigned int result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_new_edge" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_new_edge" "', 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 '" "twa_graph_new_edge" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "twa_graph_new_edge" "', argument " "4"" of type '" "bdd""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_edge" "', argument " "4"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "twa_graph_new_edge" "', argument " "5"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_edge" "', argument " "5"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->new_edge(arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_edge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  bdd arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  unsigned int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_new_edge" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_new_edge" "', 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 '" "twa_graph_new_edge" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "twa_graph_new_edge" "', argument " "4"" of type '" "bdd""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_edge" "', argument " "4"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->new_edge(arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_edge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_new_edge", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    PyObject *retobj = _wrap_twa_graph_new_edge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_twa_graph_new_edge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_new_edge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::new_edge(unsigned int,unsigned int,bdd,spot::acc_cond::mark_t)\n"
    "    spot::twa_graph::new_edge(unsigned int,unsigned int,bdd)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_acc_edge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  bdd arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  unsigned int result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_new_acc_edge" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_new_acc_edge" "', 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 '" "twa_graph_new_acc_edge" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "twa_graph_new_acc_edge" "', argument " "4"" of type '" "bdd""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_acc_edge" "', argument " "4"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "twa_graph_new_acc_edge" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = (unsigned int)(arg1)->new_acc_edge(arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_acc_edge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  bdd arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  unsigned int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_new_acc_edge" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_new_acc_edge" "', 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 '" "twa_graph_new_acc_edge" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "twa_graph_new_acc_edge" "', argument " "4"" of type '" "bdd""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_acc_edge" "', argument " "4"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->new_acc_edge(arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_acc_edge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_new_acc_edge", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    PyObject *retobj = _wrap_twa_graph_new_acc_edge__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_twa_graph_new_acc_edge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_new_acc_edge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::new_acc_edge(unsigned int,unsigned int,bdd,bool)\n"
    "    spot::twa_graph::new_acc_edge(unsigned int,unsigned int,bdd)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_univ_edge__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  SwigValueWrapper< std::initializer_list< unsigned int > > arg3 ;
  bdd arg4 ;
  spot::acc_cond::mark_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  unsigned int result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_new_univ_edge" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_new_univ_edge" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "twa_graph_new_univ_edge" "', argument " "4"" of type '" "bdd""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_univ_edge" "', argument " "4"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "twa_graph_new_univ_edge" "', argument " "5"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_univ_edge" "', argument " "5"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->new_univ_edge(arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_univ_edge__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  SwigValueWrapper< std::initializer_list< unsigned int > > arg3 ;
  bdd arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  unsigned int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_new_univ_edge" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_new_univ_edge" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "twa_graph_new_univ_edge" "', argument " "4"" of type '" "bdd""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_univ_edge" "', argument " "4"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->new_univ_edge(arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_out(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_out", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_out" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_out" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (arg1)->out(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::state_out< spot::twa_graph::graph_t >(result)), SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_out_iteraser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_out_iteraser", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_out_iteraser" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_out_iteraser" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (arg1)->out_iteraser(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::killer_edge_iterator< spot::twa_graph::graph_t >(result)), SWIGTYPE_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_univ_dests__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_univ_dests" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_univ_dests" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    resultobj = SWIG_NewPointerObj(new spot::internal::const_universal_dests(((spot::twa_graph const *)arg1)->univ_dests(arg2)), SWIGTYPE_p_spot__internal__const_universal_dests,
      SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_univ_dests__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_graph::edge_storage_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_univ_dests" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_univ_dests" "', argument " "2"" of type '" "spot::twa_graph::edge_storage_t const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_univ_dests" "', argument " "2"" of type '" "spot::twa_graph::edge_storage_t const &""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_graph::edge_storage_t * >(argp2);
  {
    resultobj = SWIG_NewPointerObj(new spot::internal::const_universal_dests(((spot::twa_graph const *)arg1)->univ_dests((spot::twa_graph::edge_storage_t const &)*arg2)), SWIGTYPE_p_spot__internal__const_universal_dests,
      SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_univ_dests(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_univ_dests", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_twa_graph_univ_dests__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_univ_dests__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_univ_dests'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::univ_dests(unsigned int) const\n"
    "    spot::twa_graph::univ_dests(spot::twa_graph::edge_storage_t const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_is_existential(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_is_existential" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((spot::twa_graph const *)arg1)->is_existential();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edges" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    resultobj = SWIG_NewPointerObj(new spot::internal::all_trans< spot::twa_graph::graph_t >((arg1)->edges()), SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
      SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_is_dead_edge__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_is_dead_edge" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_is_dead_edge" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::twa_graph const *)arg1)->is_dead_edge(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_is_dead_edge__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_graph::graph_t::edge_storage_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_is_dead_edge" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_storage_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_is_dead_edge" "', argument " "2"" of type '" "spot::twa_graph::graph_t::edge_storage_t const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_is_dead_edge" "', argument " "2"" of type '" "spot::twa_graph::graph_t::edge_storage_t const &""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_graph::graph_t::edge_storage_t * >(argp2);
  {
    try {
      result = (bool)((spot::twa_graph const *)arg1)->is_dead_edge((spot::twa_graph::graph_t::edge_storage_t const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_is_dead_edge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_is_dead_edge", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_storage_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_twa_graph_is_dead_edge__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_is_dead_edge__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_is_dead_edge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::is_dead_edge(unsigned int) const\n"
    "    spot::twa_graph::is_dead_edge(spot::twa_graph::graph_t::edge_storage_t const &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_merge_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_merge_edges" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->merge_edges();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_merge_univ_dests(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_merge_univ_dests" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->merge_univ_dests();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_merge_states__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::parallel_policy arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_merge_states" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__parallel_policy,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_merge_states" "', argument " "2"" of type '" "spot::parallel_policy""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_merge_states" "', argument " "2"" of type '" "spot::parallel_policy""'");
    } else {
      spot::parallel_policy * temp = reinterpret_cast< spot::parallel_policy * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->merge_states(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_merge_states__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_merge_states" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->merge_states();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_merge_states(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_merge_states", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_graph_merge_states__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_merge_states__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_merge_states'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::merge_states(spot::parallel_policy)\n"
    "    spot::twa_graph::merge_states()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_merge_states_of__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  bool arg2 ;
  std::vector< bool,std::allocator< bool > > *arg3 = (std::vector< bool,std::allocator< bool > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_merge_states_of" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_merge_states_of" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "twa_graph_merge_states_of" "', argument " "3"" of type '" "std::vector< bool,std::allocator< bool > > const *""'"); 
  }
  arg3 = reinterpret_cast< std::vector< bool,std::allocator< bool > > * >(argp3);
  {
    try {
      result = (unsigned int)(arg1)->merge_states_of(arg2,(std::vector< bool,std::allocator< bool > > const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_merge_states_of__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_merge_states_of" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_merge_states_of" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (unsigned int)(arg1)->merge_states_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_merge_states_of__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_merge_states_of" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->merge_states_of();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_merge_states_of(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_merge_states_of", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_graph_merge_states_of__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_merge_states_of__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_twa_graph_merge_states_of__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_merge_states_of'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::merge_states_of(bool,std::vector< bool,std::allocator< bool > > const *)\n"
    "    spot::twa_graph::merge_states_of(bool)\n"
    "    spot::twa_graph::merge_states_of()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_purge_dead_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_purge_dead_states" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->purge_dead_states();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_purge_unreachable_states__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_graph::shift_action *arg2 = (spot::twa_graph::shift_action *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_purge_unreachable_states" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_f_r_q_const__std__vector__unsigned_int_std__allocator__unsigned_int_____p_void__void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_purge_unreachable_states" "', argument " "2"" of type '" "spot::twa_graph::shift_action *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_graph::shift_action * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "twa_graph_purge_unreachable_states" "', argument " "3"" of type '" "void *""'"); 
  }
  {
    try {
      (arg1)->purge_unreachable_states(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_purge_unreachable_states__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_graph::shift_action *arg2 = (spot::twa_graph::shift_action *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_purge_unreachable_states" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_f_r_q_const__std__vector__unsigned_int_std__allocator__unsigned_int_____p_void__void, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_purge_unreachable_states" "', argument " "2"" of type '" "spot::twa_graph::shift_action *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_graph::shift_action * >(argp2);
  {
    try {
      (arg1)->purge_unreachable_states(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_purge_unreachable_states__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_purge_unreachable_states" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->purge_unreachable_states();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_purge_unreachable_states(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_purge_unreachable_states", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_graph_purge_unreachable_states__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_purge_unreachable_states__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_twa_graph_purge_unreachable_states__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_purge_unreachable_states'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::purge_unreachable_states(spot::twa_graph::shift_action *,void *)\n"
    "    spot::twa_graph::purge_unreachable_states(spot::twa_graph::shift_action *)\n"
    "    spot::twa_graph::purge_unreachable_states()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_remove_unused_ap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_remove_unused_ap" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->remove_unused_ap();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_copy_state_names_from(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_copy_state_names_from", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_copy_state_names_from" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_copy_state_names_from" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->copy_state_names_from((spot::const_twa_graph_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_acc_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_state_acc_sets", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_state_acc_sets" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_state_acc_sets" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::twa_graph const *)arg1)->state_acc_sets(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_is_accepting__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_state_is_accepting" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_state_is_accepting" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::twa_graph const *)arg1)->state_is_accepting(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_is_accepting__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_state_is_accepting" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_state_is_accepting" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (bool)((spot::twa_graph const *)arg1)->state_is_accepting((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_is_accepting(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_state_is_accepting", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__state, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_twa_graph_state_is_accepting__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_state_is_accepting__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_state_is_accepting'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::state_is_accepting(unsigned int) const\n"
    "    spot::twa_graph::state_is_accepting(spot::state const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  spot::twa_graph *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph___eq__", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph___eq__" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph___eq__" "', argument " "2"" of type '" "spot::twa_graph const &""'");
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph___eq__" "', argument " "2"" of type '" "spot::twa_graph const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared2 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp2);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp2);
      arg2 = const_cast< spot::twa_graph * >(tempshared2.get());
    } else {
      arg2 = const_cast< spot::twa_graph * >(reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp2)->get());
    }
  }
  {
    try {
      result = (bool)((spot::twa_graph const *)arg1)->operator ==((spot::twa_graph const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_twa_graph_kill_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_kill_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_kill_state" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_kill_state" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      (arg1)->kill_state(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_dump_storage_as_dot__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  std::ostream *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_dump_storage_as_dot" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_dump_storage_as_dot" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_dump_storage_as_dot" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "twa_graph_dump_storage_as_dot" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      ((spot::twa_graph const *)arg1)->dump_storage_as_dot(*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_dump_storage_as_dot__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph const > tempshared1 ;
  std::shared_ptr< spot::twa_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_dump_storage_as_dot" "', argument " "1"" of type '" "spot::twa_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_dump_storage_as_dot" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_dump_storage_as_dot" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      ((spot::twa_graph const *)arg1)->dump_storage_as_dot(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_dump_storage_as_dot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_dump_storage_as_dot", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_dump_storage_as_dot__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_twa_graph_dump_storage_as_dot__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_dump_storage_as_dot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::dump_storage_as_dot(std::ostream &,char const *) const\n"
    "    spot::twa_graph::dump_storage_as_dot(std::ostream &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_univ_edge__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  bdd arg4 ;
  spot::acc_cond::mark_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  unsigned int result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_new_univ_edge" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_new_univ_edge" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(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 '" "twa_graph_new_univ_edge" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_univ_edge" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "twa_graph_new_univ_edge" "', argument " "4"" of type '" "bdd""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_univ_edge" "', argument " "4"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "twa_graph_new_univ_edge" "', argument " "5"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_univ_edge" "', argument " "5"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp5);
      arg5 = *temp;
      if (SWIG_IsNewObj(res5)) delete temp;
    }
  }
  {
    try {
      result = (unsigned int)spot_twa_graph_new_univ_edge__SWIG_4(arg1,arg2,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_univ_edge__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  bdd arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  unsigned int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_new_univ_edge" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_new_univ_edge" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(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 '" "twa_graph_new_univ_edge" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_univ_edge" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "twa_graph_new_univ_edge" "', argument " "4"" of type '" "bdd""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_new_univ_edge" "', argument " "4"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = (unsigned int)spot_twa_graph_new_univ_edge__SWIG_4(arg1,arg2,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg3,SWIG_STD_MOVE(arg4));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_new_univ_edge(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_new_univ_edge", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_twa_graph_new_univ_edge__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_twa_graph_new_univ_edge__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_twa_graph_new_univ_edge__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 5) {
    int _v = 0;
    {
      int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    PyObject *retobj = _wrap_twa_graph_new_univ_edge__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_4:
  
  if (argc == 5) {
    int _v = 0;
    {
      
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_twa_graph_new_univ_edge__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_twa_graph_new_univ_edge__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_new_univ_edge'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::new_univ_edge(unsigned int,std::initializer_list< unsigned int >,bdd,spot::acc_cond::mark_t)\n"
    "    spot::twa_graph::new_univ_edge(unsigned int,std::initializer_list< unsigned int >,bdd)\n"
    "    spot::twa_graph::new_univ_edge(unsigned int,std::vector< unsigned int,std::allocator< unsigned int > > const &,bdd,spot::acc_cond::mark_t)\n"
    "    spot::twa_graph::new_univ_edge(unsigned int,std::vector< unsigned int,std::allocator< unsigned int > > const &,bdd)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_set_univ_init_state__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_set_univ_init_state" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    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 '" "twa_graph_set_univ_init_state" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_set_univ_init_state" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      spot_twa_graph_set_univ_init_state__SWIG_2(arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_set_univ_init_state(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_set_univ_init_state", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__initializer_listT_unsigned_int_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_twa_graph_set_univ_init_state__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_graph_set_univ_init_state__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_set_univ_init_state'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_graph::set_univ_init_state(std::initializer_list< spot::twa_graph::state_num > const &)\n"
    "    spot::twa_graph::set_univ_init_state(std::vector< unsigned int,std::allocator< unsigned int > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_graph_report_univ_dest(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph *arg1 = (spot::twa_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_graph > tempshared1 ;
  std::shared_ptr< spot::twa_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_report_univ_dest", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_report_univ_dest" "', argument " "1"" of type '" "spot::twa_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_graph > * >(argp1);
      arg1 = const_cast< spot::twa_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_report_univ_dest" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      spot_twa_graph_report_univ_dest(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_graph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_graph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_make_twa_graph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_twa_graph" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::make_twa_graph((std::shared_ptr< spot::bdd_dict > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_twa_graph__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  spot::twa::prop_set arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_twa_graph" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::make_twa_graph((std::shared_ptr< spot::twa_graph > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_twa_graph__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::twa::prop_set arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_twa_graph" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "make_twa_graph" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::make_twa_graph((std::shared_ptr< spot::twa_graph const > const &)*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_twa_graph__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::twa::prop_set arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_twa_graph" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::make_twa_graph((std::shared_ptr< spot::twa_graph const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_twa_graph__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::twa::prop_set arg2 ;
  bool arg3 ;
  unsigned int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_twa_graph" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "make_twa_graph" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "make_twa_graph" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = spot::make_twa_graph((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_twa_graph__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::twa::prop_set arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_twa_graph" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "make_twa_graph" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::make_twa_graph((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_twa_graph__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::twa::prop_set arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_twa_graph" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_twa_graph" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::make_twa_graph((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_twa_graph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "make_twa_graph", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_make_twa_graph__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    PyObject *retobj = _wrap_make_twa_graph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_make_twa_graph__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_make_twa_graph__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_make_twa_graph__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_make_twa_graph__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_make_twa_graph__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'make_twa_graph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::make_twa_graph(spot::bdd_dict_ptr const &)\n"
    "    spot::make_twa_graph(spot::twa_graph_ptr const &,spot::twa::prop_set)\n"
    "    spot::make_twa_graph(spot::const_twa_graph_ptr const &,spot::twa::prop_set,bool)\n"
    "    spot::make_twa_graph(spot::const_twa_graph_ptr const &,spot::twa::prop_set)\n"
    "    spot::make_twa_graph(spot::const_twa_ptr const &,spot::twa::prop_set,bool,unsigned int)\n"
    "    spot::make_twa_graph(spot::const_twa_ptr const &,spot::twa::prop_set,bool)\n"
    "    spot::make_twa_graph(spot::const_twa_ptr const &,spot::twa::prop_set)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_twa_graph_state_out(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > *arg1 = (spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > *) 0 ;
  SwigValueWrapper< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data >::edge > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_twa_graph_state_out", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_graph_state_out" "', argument " "1"" of type '" "spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > *""'"); 
  }
  arg1 = reinterpret_cast< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_twa_graph_state_out" "', argument " "2"" of type '" "spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_twa_graph_state_out" "', argument " "2"" of type '" "spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge""'");
    } else {
      spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge * temp = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *)new spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_out_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_state_out_begin" "', argument " "1"" of type '" "spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      result = ((spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > const *)arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >(result)), SWIGTYPE_p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_out_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_state_out_end" "', argument " "1"" of type '" "spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      result = ((spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > const *)arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >(result)), SWIGTYPE_p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_out_recycle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  SwigValueWrapper< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data >::edge > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_state_out_recycle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_state_out_recycle" "', argument " "1"" of type '" "spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_state_out_recycle" "', argument " "2"" of type '" "spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_state_out_recycle" "', argument " "2"" of type '" "spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge""'");
    } else {
      spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge * temp = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->recycle(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_state_out___iter__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_state_out___iter__" "', argument " "1"" of type '" "spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)spot_internal_state_out_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg__Sg____iter__(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_twa_graph_state_out(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_graph_state_out" "', argument " "1"" of type '" "spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_graph_state_out_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_graph_state_out_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_twa_graph_killer_edge_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > *arg1 = (spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > *) 0 ;
  SwigValueWrapper< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data >::edge > arg2 ;
  spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::state_storage_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_twa_graph_killer_edge_iterator", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_graph_killer_edge_iterator" "', argument " "1"" of type '" "spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > *""'"); 
  }
  arg1 = reinterpret_cast< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_twa_graph_killer_edge_iterator" "', argument " "2"" of type '" "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_twa_graph_killer_edge_iterator" "', argument " "2"" of type '" "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge""'");
    } else {
      spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge * temp = reinterpret_cast< spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__state_storage_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_twa_graph_killer_edge_iterator" "', argument " "3"" of type '" "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::state_storage_t &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_twa_graph_killer_edge_iterator" "', argument " "3"" of type '" "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::state_storage_t &""'"); 
  }
  arg3 = reinterpret_cast< spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::state_storage_t * >(argp3);
  {
    try {
      result = (spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *)new spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >(arg1,arg2,*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_killer_edge_iterator_erase(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_killer_edge_iterator_erase" "', argument " "1"" of type '" "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      (arg1)->erase();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_killer_edge_iterator_current(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_killer_edge_iterator_current" "', argument " "1"" of type '" "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      result = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) &spot_internal_killer_edge_iterator_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg__Sg__current(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_killer_edge_iterator_advance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_killer_edge_iterator_advance" "', argument " "1"" of type '" "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      spot_internal_killer_edge_iterator_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg__Sg__advance(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_killer_edge_iterator___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_killer_edge_iterator___bool__" "', argument " "1"" of type '" "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      result = (bool)spot_internal_killer_edge_iterator_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg__Sg____bool__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_twa_graph_killer_edge_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_graph_killer_edge_iterator" "', argument " "1"" of type '" "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_graph_killer_edge_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_graph_killer_edge_iterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_twa_graph_all_trans(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::tv_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__conditionalT_std__is_constT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t__value_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_const_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_t__type,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_graph_all_trans" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::tv_t &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_twa_graph_all_trans" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::tv_t &""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::tv_t * >(argp1);
  {
    try {
      result = (spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *)new spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_all_trans_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::all_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_all_trans_begin" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      result = ((spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > const *)arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::iter_t(result)), SWIGTYPE_p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_all_trans_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::all_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_all_trans_end" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      result = ((spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > const *)arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::iter_t(result)), SWIGTYPE_p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_all_trans___iter__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_all_trans___iter__" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)spot_internal_all_trans_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg__Sg____iter__(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_twa_graph_all_trans(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *arg1 = (spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_graph_all_trans" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_graph_all_trans_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_graph_all_trans_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_twa_graph_edge_boxed_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< spot::twa_graph_edge_data,false > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_twa_graph_edge_boxed_data", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::internal::boxed_label< spot::twa_graph_edge_data,false > *)new spot::internal::boxed_label< spot::twa_graph_edge_data,false >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_boxed_data_data__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< spot::twa_graph_edge_data,false > *arg1 = (spot::internal::boxed_label< spot::twa_graph_edge_data,false > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::twa_graph_edge_data *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_boxed_data_data" "', argument " "1"" of type '" "spot::internal::boxed_label< spot::twa_graph_edge_data,false > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::boxed_label< spot::twa_graph_edge_data,false > * >(argp1);
  {
    try {
      result = (spot::twa_graph_edge_data *) &(arg1)->data();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_boxed_data_data__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< spot::twa_graph_edge_data,false > *arg1 = (spot::internal::boxed_label< spot::twa_graph_edge_data,false > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::twa_graph_edge_data *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_boxed_data_data" "', argument " "1"" of type '" "spot::internal::boxed_label< spot::twa_graph_edge_data,false > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::boxed_label< spot::twa_graph_edge_data,false > * >(argp1);
  {
    try {
      result = (spot::twa_graph_edge_data *) &((spot::internal::boxed_label< spot::twa_graph_edge_data,false > const *)arg1)->data();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_graph_edge_data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_boxed_data_data(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_graph_edge_boxed_data_data", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_graph_edge_boxed_data_data__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_graph_edge_boxed_data_data__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_graph_edge_boxed_data_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::internal::boxed_label< spot::twa_graph_edge_data,false >::data()\n"
    "    spot::internal::boxed_label< spot::twa_graph_edge_data,false >::data() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_twa_graph_edge_boxed_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< spot::twa_graph_edge_data,false > *arg1 = (spot::internal::boxed_label< spot::twa_graph_edge_data,false > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_graph_edge_boxed_data" "', argument " "1"" of type '" "spot::internal::boxed_label< spot::twa_graph_edge_data,false > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::boxed_label< spot::twa_graph_edge_data,false > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_graph_edge_boxed_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_graph_edge_boxed_data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_twa_graph_edge_storage_dst_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_edge_storage_dst_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage_dst_set" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_edge_storage_dst_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->dst = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage_dst_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage_dst_get" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp1);
  result = (unsigned int) ((arg1)->dst);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage_next_succ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_edge_storage_next_succ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage_next_succ_set" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_edge_storage_next_succ_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->next_succ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage_next_succ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage_next_succ_get" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp1);
  result = (unsigned int) ((arg1)->next_succ);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage_src_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_edge_storage_src_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage_src_set" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_graph_edge_storage_src_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->src = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage_src_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage_src_get" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp1);
  result = (unsigned int) ((arg1)->src);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_graph_edge_storage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_twa_graph_edge_storage", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *)new spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) 0 ;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_edge_storage___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage___lt__" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_storage___lt__" "', argument " "2"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_edge_storage___lt__" "', argument " "2"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const &""'"); 
  }
  arg2 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp2);
  {
    try {
      result = (bool)((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const *)arg1)->operator <((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_twa_graph_edge_storage___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) 0 ;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_graph_edge_storage___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_graph_edge_storage___eq__" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_graph_edge_storage___eq__" "', argument " "2"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_graph_edge_storage___eq__" "', argument " "2"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const &""'"); 
  }
  arg2 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp2);
  {
    try {
      result = (bool)((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const *)arg1)->operator ==((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_twa_graph_edge_storage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_graph_edge_storage" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_graph_edge_storage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_graph_edge_storage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_aig__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  unsigned int arg3 ;
  spot::bdd_dict_ptr arg4 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  spot::aig *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) 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_aig" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_aig" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_aig" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_aig" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_aig" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_aig" "', argument " "4"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp4);
  }
  {
    try {
      result = (spot::aig *)new spot::aig((std::vector< std::string,std::allocator< std::string > > const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  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_new_aig__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  unsigned int arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  spot::aig *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) 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_aig" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_aig" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_aig" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_aig" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_aig" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (spot::aig *)new spot::aig((std::vector< std::string,std::allocator< std::string > > const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  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_new_aig__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  spot::bdd_dict_ptr arg4 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  spot::aig *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_aig" "', 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 '" "new_aig" "', 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 '" "new_aig" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_aig" "', argument " "4"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp4) arg4 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp4));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp4);
  }
  {
    try {
      result = (spot::aig *)new spot::aig(arg1,arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_aig__SWIG_3(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 ;
  spot::aig *result = 0 ;
  
  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 '" "new_aig" "', 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 '" "new_aig" "', 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 '" "new_aig" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (spot::aig *)new spot::aig(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_aig(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_aig", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_new_aig__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_aig__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_new_aig__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_new_aig__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_aig'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::aig(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &,unsigned int,spot::bdd_dict_ptr)\n"
    "    spot::aig::aig(std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &,unsigned int)\n"
    "    spot::aig::aig(unsigned int,unsigned int,unsigned int,spot::bdd_dict_ptr)\n"
    "    spot::aig::aig(unsigned int,unsigned int,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_aig(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_aig" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_get_safe_point_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::aig::safe_point result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_get_safe_point_" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::aig const *)arg1)->get_safe_point_();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_roll_back___SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  spot::aig::safe_point arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< std::tuple< std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >,std::vector< std::pair< unsigned int,bdd >,std::allocator< std::pair< unsigned int,bdd > > >,std::vector< bdd,std::allocator< bdd > > > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_roll_back_" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,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 '" "aig_roll_back_" "', argument " "2"" of type '" "spot::aig::safe_point""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_roll_back_" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (arg1)->roll_back_(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::aig::safe_stash(result)), SWIGTYPE_p_std__tupleT_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t_std__vectorT_std__pairT_unsigned_int_bdd_t_std__allocatorT_std__pairT_unsigned_int_bdd_t_t_t_std__vectorT_bdd_std__allocatorT_bdd_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_roll_back___SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  spot::aig::safe_point arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  SwigValueWrapper< std::tuple< std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >,std::vector< std::pair< unsigned int,bdd >,std::allocator< std::pair< unsigned int,bdd > > >,std::vector< bdd,std::allocator< bdd > > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_roll_back_" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,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 '" "aig_roll_back_" "', argument " "2"" of type '" "spot::aig::safe_point""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (arg1)->roll_back_(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::aig::safe_stash(result)), SWIGTYPE_p_std__tupleT_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t_std__vectorT_std__pairT_unsigned_int_bdd_t_std__allocatorT_std__pairT_unsigned_int_bdd_t_t_t_std__vectorT_bdd_std__allocatorT_bdd_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_roll_back_(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_roll_back_", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_roll_back___SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_roll_back___SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_roll_back_'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::roll_back_(spot::aig::safe_point,bool)\n"
    "    spot::aig::roll_back_(spot::aig::safe_point)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_reapply_(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  spot::aig::safe_point arg2 ;
  spot::aig::safe_stash *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_reapply_", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_reapply_" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::pair< unsigned int,unsigned int > *ptr = (std::pair< unsigned int,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 '" "aig_reapply_" "', argument " "2"" of type '" "spot::aig::safe_point""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__tupleT_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t_std__vectorT_std__pairT_unsigned_int_bdd_t_std__allocatorT_std__pairT_unsigned_int_bdd_t_t_t_std__vectorT_bdd_std__allocatorT_bdd_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aig_reapply_" "', argument " "3"" of type '" "spot::aig::safe_stash const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_reapply_" "', argument " "3"" of type '" "spot::aig::safe_stash const &""'"); 
  }
  arg3 = reinterpret_cast< spot::aig::safe_stash * >(argp3);
  {
    try {
      (arg1)->reapply_(arg2,(spot::aig::safe_stash const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_num_outputs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_num_outputs" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->num_outputs();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_outputs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_outputs" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< unsigned int,std::allocator< unsigned int > > *) &((spot::aig const *)arg1)->outputs();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_output_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_output_names" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< std::string,std::allocator< std::string > > *) &((spot::aig const *)arg1)->output_names();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_num_inputs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_num_inputs" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->num_inputs();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_input_names(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_input_names" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< std::string,std::allocator< std::string > > *) &((spot::aig const *)arg1)->input_names();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_num_latches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_num_latches" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->num_latches();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_next_latches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_next_latches" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< unsigned int,std::allocator< unsigned int > > *) &((spot::aig const *)arg1)->next_latches();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_num_gates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_num_gates" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->num_gates();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_gates(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_gates" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *) &((spot::aig const *)arg1)->gates();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_max_var(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_max_var" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->max_var();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_input_var__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  unsigned int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_input_var" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_input_var" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_input_var" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->input_var(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_input_var__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_input_var" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_input_var" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->input_var(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_input_var(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_input_var", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_input_var__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_input_var__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_input_var'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::input_var(unsigned int,bool) const\n"
    "    spot::aig::input_var(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_input_bdd__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bdd result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_input_bdd" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_input_bdd" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_input_bdd" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = ((spot::aig const *)arg1)->input_bdd(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_input_bdd__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bdd result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_input_bdd" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_input_bdd" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::aig const *)arg1)->input_bdd(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_input_bdd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_input_bdd", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_input_bdd__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_input_bdd__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_input_bdd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::input_bdd(unsigned int,bool) const\n"
    "    spot::aig::input_bdd(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_latch_var__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  unsigned int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_latch_var" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_latch_var" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_latch_var" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->latch_var(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_latch_var__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_latch_var" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_latch_var" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->latch_var(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_latch_var(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_latch_var", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_latch_var__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_latch_var__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_latch_var'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::latch_var(unsigned int,bool) const\n"
    "    spot::aig::latch_var(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_latch_bdd__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bdd result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_latch_bdd" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_latch_bdd" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_latch_bdd" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = ((spot::aig const *)arg1)->latch_bdd(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_latch_bdd__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bdd result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_latch_bdd" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_latch_bdd" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::aig const *)arg1)->latch_bdd(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_latch_bdd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_latch_bdd", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_latch_bdd__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_latch_bdd__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_latch_bdd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::latch_bdd(unsigned int,bool) const\n"
    "    spot::aig::latch_bdd(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_gate_var__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  unsigned int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_gate_var" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_gate_var" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_gate_var" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->gate_var(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_gate_var__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_gate_var" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_gate_var" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->gate_var(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_gate_var(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_gate_var", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_gate_var__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_gate_var__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_gate_var'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::gate_var(unsigned int,bool) const\n"
    "    spot::aig::gate_var(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_gate_bdd__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bdd result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_gate_bdd" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_gate_bdd" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_gate_bdd" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = ((spot::aig const *)arg1)->gate_bdd(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_gate_bdd__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bdd result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_gate_bdd" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_gate_bdd" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::aig const *)arg1)->gate_bdd(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_gate_bdd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_gate_bdd", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_gate_bdd__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_gate_bdd__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_gate_bdd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::gate_bdd(unsigned int,bool) const\n"
    "    spot::aig::gate_bdd(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_aigvar2bdd__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bdd result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_aigvar2bdd" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_aigvar2bdd" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_aigvar2bdd" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = ((spot::aig const *)arg1)->aigvar2bdd(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_aigvar2bdd__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bdd result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_aigvar2bdd" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_aigvar2bdd" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::aig const *)arg1)->aigvar2bdd(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_aigvar2bdd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_aigvar2bdd", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_aigvar2bdd__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_aigvar2bdd__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_aigvar2bdd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::aigvar2bdd(unsigned int,bool) const\n"
    "    spot::aig::aigvar2bdd(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_bdd2aigvar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  bdd *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_bdd2aigvar", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_bdd2aigvar" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_bdd2aigvar" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_bdd2aigvar" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  {
    try {
      result = (unsigned int)((spot::aig const *)arg1)->bdd2aigvar((bdd const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_bdd2INFvar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  bdd *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_bdd2INFvar", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_bdd2INFvar" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_bdd2INFvar" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_bdd2INFvar" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  {
    try {
      result = (unsigned int)(arg1)->bdd2INFvar((bdd const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_bdd2ISOPvar__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  bdd *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_bdd2ISOPvar" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_bdd2ISOPvar" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_bdd2ISOPvar" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_bdd2ISOPvar" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (unsigned int)(arg1)->bdd2ISOPvar((bdd const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_bdd2ISOPvar__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  bdd *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_bdd2ISOPvar" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_bdd2ISOPvar" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_bdd2ISOPvar" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  {
    try {
      result = (unsigned int)(arg1)->bdd2ISOPvar((bdd const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_bdd2ISOPvar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_bdd2ISOPvar", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_bdd2ISOPvar__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_bdd2ISOPvar__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_bdd2ISOPvar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::bdd2ISOPvar(bdd const &,int const)\n"
    "    spot::aig::bdd2ISOPvar(bdd const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_encode_bdd__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  std::vector< bdd,std::allocator< bdd > > *arg2 = 0 ;
  char arg3 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  char val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_encode_bdd" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< bdd,std::allocator< bdd > > *ptr = (std::vector< bdd,std::allocator< bdd > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_encode_bdd" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "aig_encode_bdd" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "aig_encode_bdd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = (unsigned int)(arg1)->encode_bdd((std::vector< bdd,std::allocator< bdd > > const &)*arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_encode_bdd__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  std::vector< bdd,std::allocator< bdd > > *arg2 = 0 ;
  char arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  char val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  unsigned int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_encode_bdd" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< bdd,std::allocator< bdd > > *ptr = (std::vector< bdd,std::allocator< bdd > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_encode_bdd" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "aig_encode_bdd" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (unsigned int)(arg1)->encode_bdd((std::vector< bdd,std::allocator< bdd > > const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_encode_bdd__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  std::vector< bdd,std::allocator< bdd > > *arg2 = 0 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  char val3 ;
  int ecode3 = 0 ;
  unsigned int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_encode_bdd" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< bdd,std::allocator< bdd > > *ptr = (std::vector< bdd,std::allocator< bdd > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_encode_bdd" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      result = (unsigned int)(arg1)->encode_bdd((std::vector< bdd,std::allocator< bdd > > const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_encode_bdd__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  std::vector< bdd,std::allocator< bdd > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_encode_bdd" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< bdd,std::allocator< bdd > > *ptr = (std::vector< bdd,std::allocator< bdd > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (unsigned int)(arg1)->encode_bdd((std::vector< bdd,std::allocator< bdd > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_encode_bdd__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  bdd *arg2 = 0 ;
  char arg3 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_encode_bdd" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_encode_bdd" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "aig_encode_bdd" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "aig_encode_bdd" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = (unsigned int)(arg1)->encode_bdd((bdd const &)*arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_encode_bdd__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  bdd *arg2 = 0 ;
  char arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  unsigned int result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_encode_bdd" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_encode_bdd" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "aig_encode_bdd" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = (unsigned int)(arg1)->encode_bdd((bdd const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_encode_bdd__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  bdd *arg2 = 0 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  unsigned int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_encode_bdd" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  ecode3 = SWIG_AsVal_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aig_encode_bdd" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      result = (unsigned int)(arg1)->encode_bdd((bdd const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_encode_bdd__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  bdd *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_encode_bdd" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_encode_bdd" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  {
    try {
      result = (unsigned int)(arg1)->encode_bdd((bdd const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_encode_bdd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_encode_bdd", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_bdd, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_aig_encode_bdd__SWIG_7(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_encode_bdd__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_bdd, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_aig_encode_bdd__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_encode_bdd__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_bdd, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_aig_encode_bdd__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_aig_encode_bdd__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_bdd, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_7;
    PyObject *retobj = _wrap_aig_encode_bdd__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_7:
  
  if (argc == 5) {
    PyObject *retobj = _wrap_aig_encode_bdd__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_encode_bdd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::encode_bdd(std::vector< bdd,std::allocator< bdd > > const &,char,bool,int)\n"
    "    spot::aig::encode_bdd(std::vector< bdd,std::allocator< bdd > > const &,char,bool)\n"
    "    spot::aig::encode_bdd(std::vector< bdd,std::allocator< bdd > > const &,char)\n"
    "    spot::aig::encode_bdd(std::vector< bdd,std::allocator< bdd > > const &)\n"
    "    spot::aig::encode_bdd(bdd const &,char,bool,int)\n"
    "    spot::aig::encode_bdd(bdd const &,char,bool)\n"
    "    spot::aig::encode_bdd(bdd const &,char)\n"
    "    spot::aig::encode_bdd(bdd const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_set_output(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_set_output", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_set_output" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_set_output" "', 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 '" "aig_set_output" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      (arg1)->set_output(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_set_next_latch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_set_next_latch", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_set_next_latch" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_set_next_latch" "', 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 '" "aig_set_next_latch" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      (arg1)->set_next_latch(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_aig_true(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_aig_true", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)spot::aig::aig_true();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_aig_false(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_aig_false", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)spot::aig::aig_false();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_aig_not(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_aig_not", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_aig_not" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_aig_not" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)(arg1)->aig_not(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_aig_and__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_aig_and" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_aig_and" "', 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 '" "aig_aig_and" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (unsigned int)(arg1)->aig_and(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_aig_and__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_aig_and" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_aig_and" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_aig_and" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp2);
  {
    try {
      result = (unsigned int)(arg1)->aig_and(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_aig_and(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_aig_and", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_aig_and__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_aig_and__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_aig_and'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::aig_and(unsigned int,unsigned int)\n"
    "    spot::aig::aig_and(std::vector< unsigned int,std::allocator< unsigned int > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_aig_or__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_aig_or" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_aig_or" "', 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 '" "aig_aig_or" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (unsigned int)(arg1)->aig_or(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_aig_or__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_aig_or" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_aig_or" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_aig_or" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp2);
  {
    try {
      result = (unsigned int)(arg1)->aig_or(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_aig_or(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_aig_or", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_aig_or__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_aig_or__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_aig_or'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::aig_or(unsigned int,unsigned int)\n"
    "    spot::aig::aig_or(std::vector< unsigned int,std::allocator< unsigned int > > &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_aig_pos(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_aig_pos", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_aig_pos" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_aig_pos" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)(arg1)->aig_pos(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_encode_all_bdds(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  std::vector< bdd,std::allocator< bdd > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_encode_all_bdds", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_encode_all_bdds" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector< bdd,std::allocator< bdd > > *ptr = (std::vector< bdd,std::allocator< bdd > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_encode_all_bdds" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_encode_all_bdds" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->encode_all_bdds((std::vector< bdd,std::allocator< bdd > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_parse_aag__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::bdd_dict_ptr arg2 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  spot::aig_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_parse_aag" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_parse_aag" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_parse_aag" "', argument " "2"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
  }
  {
    try {
      result = spot::aig::parse_aag((std::string const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_parse_aag__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::aig_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_parse_aag" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_parse_aag" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = spot::aig::parse_aag((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_parse_aag__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  std::string *arg2 = 0 ;
  spot::bdd_dict_ptr arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  spot::aig_ptr result;
  
  if ((nobjs < 3) || (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 '" "aig_parse_aag" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    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 '" "aig_parse_aag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_parse_aag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aig_parse_aag" "', argument " "3"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp3) arg3 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp3));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp3);
  }
  {
    try {
      result = spot::aig::parse_aag((char const *)arg1,(std::string const &)*arg2,SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_parse_aag__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  std::string *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  spot::aig_ptr result;
  
  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 '" "aig_parse_aag" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    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 '" "aig_parse_aag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_parse_aag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = spot::aig::parse_aag((char const *)arg1,(std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_parse_aag__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  spot::bdd_dict_ptr arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  spot::aig_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_parse_aag" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_parse_aag" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(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 '" "aig_parse_aag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_parse_aag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aig_parse_aag" "', argument " "3"" of type '" "spot::bdd_dict_ptr""'");
    }
    if (argp3) arg3 = *(reinterpret_cast< spot::bdd_dict_ptr * >(argp3));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::bdd_dict_ptr * >(argp3);
  }
  {
    try {
      result = spot::aig::parse_aag(*arg1,(std::string const &)*arg2,SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_parse_aag__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::istream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  spot::aig_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_parse_aag" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_parse_aag" "', argument " "1"" of type '" "std::istream &""'"); 
  }
  arg1 = reinterpret_cast< std::istream * >(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 '" "aig_parse_aag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_parse_aag" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = spot::aig::parse_aag(*arg1,(std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_parse_aag(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_parse_aag", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_aig_parse_aag__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_aig_parse_aag__SWIG_5(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_aig_parse_aag__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_parse_aag__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_aig_parse_aag__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_aig_parse_aag__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_parse_aag'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::parse_aag(std::string const &,spot::bdd_dict_ptr)\n"
    "    spot::aig::parse_aag(std::string const &)\n"
    "    spot::aig::parse_aag(char const *,std::string const &,spot::bdd_dict_ptr)\n"
    "    spot::aig::parse_aag(char const *,std::string const &)\n"
    "    spot::aig::parse_aag(std::istream &,std::string const &,spot::bdd_dict_ptr)\n"
    "    spot::aig::parse_aag(std::istream &,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_as_automaton__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_as_automaton" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_as_automaton" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = ((spot::aig const *)arg1)->as_automaton(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_as_automaton__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_as_automaton" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::aig const *)arg1)->as_automaton();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_as_automaton(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "aig_as_automaton", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_aig_as_automaton__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_aig_as_automaton__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'aig_as_automaton'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::aig::as_automaton(bool) const\n"
    "    spot::aig::as_automaton() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_aig_circ_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool,std::allocator< bool > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_circ_state" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (std::vector< bool,std::allocator< bool > > *) &((spot::aig const *)arg1)->circ_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_circ_state_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig const > tempshared1 ;
  std::shared_ptr< spot::aig const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_circ_state_of", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_circ_state_of" "', argument " "1"" of type '" "spot::aig const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aig_circ_state_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::aig const *)arg1)->circ_state_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_circ_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_circ_init" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->circ_init();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aig_circ_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::aig *arg1 = (spot::aig *) 0 ;
  std::vector< bool,std::allocator< bool > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::aig > tempshared1 ;
  std::shared_ptr< spot::aig > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "aig_circ_step", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aig_circ_step" "', argument " "1"" of type '" "spot::aig *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::aig > * >(argp1);
      arg1 = const_cast< spot::aig * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aig_circ_step" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aig_circ_step" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->circ_step((std::vector< bool,std::allocator< bool > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *aig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *aig_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_mealy_machine_to_aig__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  spot::aig_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_machine_to_aig" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_machine_to_aig" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::mealy_machine_to_aig((std::shared_ptr< spot::twa_graph const > const &)*arg1,(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_machine_to_aig__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  spot::aig_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_machine_to_aig" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_machine_to_aig" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    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 '" "mealy_machine_to_aig" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machine_to_aig" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "mealy_machine_to_aig" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machine_to_aig" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = spot::mealy_machine_to_aig((std::shared_ptr< spot::twa_graph > const &)*arg1,(char const *)arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_machine_to_aig__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::mealy_like *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  spot::aig_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__mealy_like,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_machine_to_aig" "', argument " "1"" of type '" "spot::mealy_like const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machine_to_aig" "', argument " "1"" of type '" "spot::mealy_like const &""'"); 
  }
  arg1 = reinterpret_cast< spot::mealy_like * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_machine_to_aig" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::mealy_machine_to_aig((spot::mealy_like const &)*arg1,(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_machine_to_aig__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::mealy_like *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  spot::aig_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__mealy_like,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_machine_to_aig" "', argument " "1"" of type '" "spot::mealy_like &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machine_to_aig" "', argument " "1"" of type '" "spot::mealy_like &""'"); 
  }
  arg1 = reinterpret_cast< spot::mealy_like * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_machine_to_aig" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    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 '" "mealy_machine_to_aig" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machine_to_aig" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    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 '" "mealy_machine_to_aig" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machine_to_aig" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = spot::mealy_machine_to_aig(*arg1,(char const *)arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_machine_to_aig(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "mealy_machine_to_aig", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_mealy_machine_to_aig__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_mealy_machine_to_aig__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_mealy_machine_to_aig__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_mealy_machine_to_aig__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'mealy_machine_to_aig'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::mealy_machine_to_aig(spot::const_twa_graph_ptr const &,char const *)\n"
    "    spot::mealy_machine_to_aig(spot::twa_graph_ptr const &,char const *,std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    spot::mealy_machine_to_aig(spot::mealy_like const &,char const *)\n"
    "    spot::mealy_machine_to_aig(spot::mealy_like &,char const *,std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_mealy_machines_to_aig__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::const_twa_graph_ptr,std::allocator< spot::const_twa_graph_ptr > > *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  spot::aig_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res) || !tmp)
    SWIG_exception_fail(SWIG_ArgError(res), "in method '" "mealy_machines_to_aig" "', argument " "1"" of type '" "std::vector<spot::const_twa_graph_ptr>""'");
    
    std::vector<spot::twa_graph_ptr>* temp;
    temp = reinterpret_cast<std::vector<spot::twa_graph_ptr>*>(tmp);
    arg1 = new std::vector<spot::const_twa_graph_ptr>(temp->begin(),
      temp->end());
    if (SWIG_IsNewObj(res)) delete temp;
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_machines_to_aig" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::mealy_machines_to_aig((std::vector< std::shared_ptr< spot::twa_graph const >,std::allocator< std::shared_ptr< spot::twa_graph const > > > const &)*arg1,(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  {
    delete arg1;
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  {
    delete arg1;
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_machines_to_aig__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  spot::aig_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_machines_to_aig" "', argument " "1"" of type '" "std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machines_to_aig" "', argument " "1"" of type '" "std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_machines_to_aig" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::mealy_machines_to_aig((std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > const &)*arg1,(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_machines_to_aig__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::const_twa_graph_ptr,std::allocator< spot::const_twa_graph_ptr > > *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > *arg4 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  spot::aig_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res) || !tmp)
    SWIG_exception_fail(SWIG_ArgError(res), "in method '" "mealy_machines_to_aig" "', argument " "1"" of type '" "std::vector<spot::const_twa_graph_ptr>""'");
    
    std::vector<spot::twa_graph_ptr>* temp;
    temp = reinterpret_cast<std::vector<spot::twa_graph_ptr>*>(tmp);
    arg1 = new std::vector<spot::const_twa_graph_ptr>(temp->begin(),
      temp->end());
    if (SWIG_IsNewObj(res)) delete temp;
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_machines_to_aig" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    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 '" "mealy_machines_to_aig" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machines_to_aig" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "mealy_machines_to_aig" "', argument " "4"" of type '" "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machines_to_aig" "', argument " "4"" of type '" "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > * >(argp4);
  {
    try {
      result = spot::mealy_machines_to_aig((std::vector< std::shared_ptr< spot::twa_graph const >,std::allocator< std::shared_ptr< spot::twa_graph const > > > const &)*arg1,(char const *)arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  {
    delete arg1;
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  {
    delete arg1;
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_machines_to_aig__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  spot::aig_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_machines_to_aig" "', argument " "1"" of type '" "std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machines_to_aig" "', argument " "1"" of type '" "std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_machines_to_aig" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    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 '" "mealy_machines_to_aig" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machines_to_aig" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "mealy_machines_to_aig" "', argument " "4"" of type '" "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mealy_machines_to_aig" "', argument " "4"" of type '" "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > * >(argp4);
  {
    try {
      result = spot::mealy_machines_to_aig((std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > const &)*arg1,(char const *)arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::aig > *smartresult = result ? new std::shared_ptr<  spot::aig >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__aig_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_machines_to_aig(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "mealy_machines_to_aig", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_mealy_machines_to_aig__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_mealy_machines_to_aig__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_mealy_machines_to_aig__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 4) {
    PyObject *retobj = _wrap_mealy_machines_to_aig__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'mealy_machines_to_aig'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::mealy_machines_to_aig(std::vector< spot::const_twa_graph_ptr,std::allocator< spot::const_twa_graph_ptr > > const &,char const *)\n"
    "    spot::mealy_machines_to_aig(std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > const &,char const *)\n"
    "    spot::mealy_machines_to_aig(std::vector< spot::const_twa_graph_ptr,std::allocator< spot::const_twa_graph_ptr > > const &,char const *,std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &)\n"
    "    spot::mealy_machines_to_aig(std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > const &,char const *,std::vector< std::string,std::allocator< std::string > > const &,std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_aiger__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_aig_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_aiger" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_aiger" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__aig_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_aiger" "', argument " "2"" of type '" "spot::const_aig_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_aig_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_aig_ptr * >(argp2);
  }
  {
    try {
      result = (std::ostream *) &spot::print_aiger(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_aiger__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_aiger" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_aiger" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_aiger" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_aiger" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (std::ostream *) &spot::print_aiger(*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_aiger(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_aiger", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_aiger__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_aiger__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_aiger'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_aiger(std::ostream &,spot::const_aig_ptr)\n"
    "    spot::print_aiger(std::ostream &,spot::const_twa_graph_ptr const &,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_outedge_combiner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::outedge_combiner *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_outedge_combiner" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::outedge_combiner *)new spot::outedge_combiner((spot::twa_graph_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__outedge_combiner, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_outedge_combiner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::outedge_combiner *arg1 = (spot::outedge_combiner *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__outedge_combiner, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_outedge_combiner" "', argument " "1"" of type '" "spot::outedge_combiner *""'"); 
  }
  arg1 = reinterpret_cast< spot::outedge_combiner * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_outedge_combiner___call__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::outedge_combiner *arg1 = (spot::outedge_combiner *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bdd result;
  
  if (!SWIG_Python_UnpackTuple(args, "outedge_combiner___call__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__outedge_combiner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outedge_combiner___call__" "', argument " "1"" of type '" "spot::outedge_combiner *""'"); 
  }
  arg1 = reinterpret_cast< spot::outedge_combiner * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outedge_combiner___call__" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (arg1)->operator ()(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_outedge_combiner_new_dests(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::outedge_combiner *arg1 = (spot::outedge_combiner *) 0 ;
  unsigned int arg2 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "outedge_combiner_new_dests", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__outedge_combiner, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outedge_combiner_new_dests" "', argument " "1"" of type '" "spot::outedge_combiner const *""'"); 
  }
  arg1 = reinterpret_cast< spot::outedge_combiner * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outedge_combiner_new_dests" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "outedge_combiner_new_dests" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "outedge_combiner_new_dests" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      ((spot::outedge_combiner const *)arg1)->new_dests(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *outedge_combiner_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__outedge_combiner, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *outedge_combiner_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_remove_alternation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  output_aborter *arg3 = (output_aborter *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_alternation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "remove_alternation" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "remove_alternation" "', argument " "3"" of type '" "output_aborter const *""'"); 
  }
  arg3 = reinterpret_cast< output_aborter * >(argp3);
  {
    try {
      result = spot::remove_alternation((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(output_aborter const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_alternation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_alternation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "remove_alternation" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::remove_alternation((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_alternation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_alternation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::remove_alternation((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_alternation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "remove_alternation", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_remove_alternation__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_remove_alternation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_remove_alternation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'remove_alternation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::remove_alternation(spot::const_twa_graph_ptr const &,bool,output_aborter const *)\n"
    "    spot::remove_alternation(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::remove_alternation(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_univ_remover_state__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::univ_remover_state *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_univ_remover_state" "', argument " "1"" of type '" "std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_univ_remover_state" "', argument " "1"" of type '" "std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > > const &""'"); 
  }
  arg1 = reinterpret_cast< std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > > * >(argp1);
  {
    try {
      result = (spot::univ_remover_state *)new spot::univ_remover_state((std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__univ_remover_state, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_univ_remover_state__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::univ_remover_state *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::univ_remover_state *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__univ_remover_state,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_univ_remover_state" "', argument " "1"" of type '" "spot::univ_remover_state const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_univ_remover_state" "', argument " "1"" of type '" "spot::univ_remover_state const &""'"); 
  }
  arg1 = reinterpret_cast< spot::univ_remover_state * >(argp1);
  {
    try {
      result = (spot::univ_remover_state *)new spot::univ_remover_state((spot::univ_remover_state const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__univ_remover_state, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_univ_remover_state(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_univ_remover_state", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_univ_remover_state__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_univ_remover_state__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_univ_remover_state'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::univ_remover_state::univ_remover_state(std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > > const &)\n"
    "    spot::univ_remover_state::univ_remover_state(spot::univ_remover_state const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_univ_remover_state_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::univ_remover_state *arg1 = (spot::univ_remover_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__univ_remover_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "univ_remover_state_states" "', argument " "1"" of type '" "spot::univ_remover_state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::univ_remover_state * >(argp1);
  {
    try {
      result = (std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > > *) &((spot::univ_remover_state const *)arg1)->states();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_univ_remover_state_is_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::univ_remover_state *arg1 = (spot::univ_remover_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__univ_remover_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "univ_remover_state_is_reset" "', argument " "1"" of type '" "spot::univ_remover_state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::univ_remover_state * >(argp1);
  {
    try {
      result = (bool)((spot::univ_remover_state const *)arg1)->is_reset();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_univ_remover_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::univ_remover_state *arg1 = (spot::univ_remover_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__univ_remover_state, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_univ_remover_state" "', argument " "1"" of type '" "spot::univ_remover_state *""'"); 
  }
  arg1 = reinterpret_cast< spot::univ_remover_state * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *univ_remover_state_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__univ_remover_state, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *univ_remover_state_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_twa_univ_remover(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_univ_remover *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_univ_remover" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::twa_univ_remover *)new spot::twa_univ_remover((spot::const_twa_graph_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_univ_remover > *smartresult = result ? new std::shared_ptr<  spot::twa_univ_remover >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_univ_remover_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_univ_remover_allocate_state_vars(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_univ_remover *arg1 = (spot::twa_univ_remover *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_univ_remover > tempshared1 ;
  std::shared_ptr< spot::twa_univ_remover > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_univ_remover_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_univ_remover_allocate_state_vars" "', argument " "1"" of type '" "spot::twa_univ_remover *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_univ_remover > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_univ_remover > * >(argp1);
      arg1 = const_cast< spot::twa_univ_remover * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_univ_remover > * >(argp1);
      arg1 = const_cast< spot::twa_univ_remover * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->allocate_state_vars();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_twa_univ_remover(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_univ_remover *arg1 = (spot::twa_univ_remover *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_univ_remover > tempshared1 ;
  std::shared_ptr< spot::twa_univ_remover > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_univ_remover_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_univ_remover" "', argument " "1"" of type '" "spot::twa_univ_remover *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_univ_remover > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_univ_remover > * >(argp1);
      arg1 = const_cast< spot::twa_univ_remover * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_univ_remover > * >(argp1);
      arg1 = const_cast< spot::twa_univ_remover * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_univ_remover_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__twa_univ_remover_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_univ_remover_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_remove_univ_otf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_univ_remover_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_univ_otf" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::remove_univ_otf((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_univ_remover > *smartresult = result ? new std::shared_ptr<  spot::twa_univ_remover >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_univ_remover_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanup_acceptance_here__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cleanup_acceptance_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cleanup_acceptance_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::cleanup_acceptance_here(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanup_acceptance_here__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cleanup_acceptance_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::cleanup_acceptance_here(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanup_acceptance_here(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "cleanup_acceptance_here", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_cleanup_acceptance_here__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_cleanup_acceptance_here__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'cleanup_acceptance_here'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::cleanup_acceptance_here(spot::twa_graph_ptr,bool)\n"
    "    spot::cleanup_acceptance_here(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_cleanup_acceptance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cleanup_acceptance" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cleanup_acceptance" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::cleanup_acceptance(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanup_acceptance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cleanup_acceptance" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::cleanup_acceptance(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanup_acceptance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "cleanup_acceptance", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_cleanup_acceptance__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_cleanup_acceptance__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'cleanup_acceptance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::cleanup_acceptance(spot::const_twa_graph_ptr,bool)\n"
    "    spot::cleanup_acceptance(spot::const_twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_simplify_acceptance_here(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simplify_acceptance_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::simplify_acceptance_here(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplify_acceptance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simplify_acceptance" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::simplify_acceptance(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nca_st_info_clause_num_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::nca_st_info *arg1 = (spot::nca_st_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "nca_st_info_clause_num_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__nca_st_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nca_st_info_clause_num_set" "', argument " "1"" of type '" "spot::nca_st_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::nca_st_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nca_st_info_clause_num_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->clause_num = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nca_st_info_clause_num_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::nca_st_info *arg1 = (spot::nca_st_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__nca_st_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nca_st_info_clause_num_get" "', argument " "1"" of type '" "spot::nca_st_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::nca_st_info * >(argp1);
  result = (unsigned int) ((arg1)->clause_num);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nca_st_info_state_num_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::nca_st_info *arg1 = (spot::nca_st_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "nca_st_info_state_num_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__nca_st_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nca_st_info_state_num_set" "', argument " "1"" of type '" "spot::nca_st_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::nca_st_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nca_st_info_state_num_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->state_num = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nca_st_info_state_num_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::nca_st_info *arg1 = (spot::nca_st_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__nca_st_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nca_st_info_state_num_get" "', argument " "1"" of type '" "spot::nca_st_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::nca_st_info * >(argp1);
  result = (unsigned int) ((arg1)->state_num);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nca_st_info_all_dst_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::nca_st_info *arg1 = (spot::nca_st_info *) 0 ;
  bitvect *arg2 = (bitvect *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "nca_st_info_all_dst_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__nca_st_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nca_st_info_all_dst_set" "', argument " "1"" of type '" "spot::nca_st_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::nca_st_info * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_bitvect, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nca_st_info_all_dst_set" "', argument " "2"" of type '" "bitvect *""'"); 
  }
  arg2 = reinterpret_cast< bitvect * >(argp2);
  if (arg1) (arg1)->all_dst = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nca_st_info_all_dst_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::nca_st_info *arg1 = (spot::nca_st_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bitvect *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__nca_st_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nca_st_info_all_dst_get" "', argument " "1"" of type '" "spot::nca_st_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::nca_st_info * >(argp1);
  result = (bitvect *) ((arg1)->all_dst);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bitvect, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_nca_st_info(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  bitvect *arg3 = (bitvect *) 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::nca_st_info *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_nca_st_info", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_nca_st_info" "', 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 '" "new_nca_st_info" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_bitvect, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_nca_st_info" "', argument " "3"" of type '" "bitvect *""'"); 
  }
  arg3 = reinterpret_cast< bitvect * >(argp3);
  {
    try {
      result = (spot::nca_st_info *)new spot::nca_st_info(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__nca_st_info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_nca_st_info(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::nca_st_info *arg1 = (spot::nca_st_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__nca_st_info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_nca_st_info" "', argument " "1"" of type '" "spot::nca_st_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::nca_st_info * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *nca_st_info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__nca_st_info, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *nca_st_info_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_nsa_to_nca__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  bool arg2 ;
  spot::vect_nca_info *arg3 = (spot::vect_nca_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nsa_to_nca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nsa_to_nca" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_std__vectorT_spot__nca_st_info_p_std__allocatorT_spot__nca_st_info_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "nsa_to_nca" "', argument " "3"" of type '" "spot::vect_nca_info *""'"); 
  }
  arg3 = reinterpret_cast< spot::vect_nca_info * >(argp3);
  {
    try {
      result = spot::nsa_to_nca(SWIG_STD_MOVE(arg1),arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nsa_to_nca__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nsa_to_nca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nsa_to_nca" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::nsa_to_nca(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nsa_to_nca__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nsa_to_nca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::nsa_to_nca(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nsa_to_nca(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "nsa_to_nca", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_nsa_to_nca__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_nsa_to_nca__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_nsa_to_nca__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'nsa_to_nca'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::nsa_to_nca(spot::const_twa_graph_ptr,bool,spot::vect_nca_info *)\n"
    "    spot::nsa_to_nca(spot::const_twa_graph_ptr,bool)\n"
    "    spot::nsa_to_nca(spot::const_twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_dnf_to_nca__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  bool arg2 ;
  spot::vect_nca_info *arg3 = (spot::vect_nca_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dnf_to_nca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dnf_to_nca" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_std__vectorT_spot__nca_st_info_p_std__allocatorT_spot__nca_st_info_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dnf_to_nca" "', argument " "3"" of type '" "spot::vect_nca_info *""'"); 
  }
  arg3 = reinterpret_cast< spot::vect_nca_info * >(argp3);
  {
    try {
      result = spot::dnf_to_nca(SWIG_STD_MOVE(arg1),arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dnf_to_nca__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dnf_to_nca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dnf_to_nca" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::dnf_to_nca(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dnf_to_nca__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dnf_to_nca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::dnf_to_nca(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dnf_to_nca(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "dnf_to_nca", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_dnf_to_nca__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_dnf_to_nca__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_dnf_to_nca__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'dnf_to_nca'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::dnf_to_nca(spot::const_twa_graph_ptr,bool,spot::vect_nca_info *)\n"
    "    spot::dnf_to_nca(spot::const_twa_graph_ptr,bool)\n"
    "    spot::dnf_to_nca(spot::const_twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_to_nca__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_nca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_nca" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::to_nca(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_nca__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_nca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::to_nca(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_nca(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "to_nca", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_to_nca__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_to_nca__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'to_nca'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::to_nca(spot::const_twa_graph_ptr,bool)\n"
    "    spot::to_nca(spot::const_twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_nsa_to_dca__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nsa_to_dca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nsa_to_dca" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::nsa_to_dca(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nsa_to_dca__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nsa_to_dca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::nsa_to_dca(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nsa_to_dca(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "nsa_to_dca", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_nsa_to_dca__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_nsa_to_dca__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'nsa_to_dca'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::nsa_to_dca(spot::const_twa_graph_ptr,bool)\n"
    "    spot::nsa_to_dca(spot::const_twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_dnf_to_dca__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dnf_to_dca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dnf_to_dca" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::dnf_to_dca(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dnf_to_dca__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dnf_to_dca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::dnf_to_dca(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dnf_to_dca(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "dnf_to_dca", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_dnf_to_dca__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_dnf_to_dca__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'dnf_to_dca'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::dnf_to_dca(spot::const_twa_graph_ptr,bool)\n"
    "    spot::dnf_to_dca(spot::const_twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_to_dca__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_dca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_dca" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::to_dca(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_dca__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_dca" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::to_dca(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_dca(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "to_dca", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_to_dca__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_to_dca__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'to_dca'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::to_dca(spot::const_twa_graph_ptr,bool)\n"
    "    spot::to_dca(spot::const_twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_copy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::twa::prop_set arg2 ;
  bool arg3 ;
  unsigned int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copy" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "copy" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copy" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "copy" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = spot::copy((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_copy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::twa::prop_set arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copy" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "copy" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "copy" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::copy((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_copy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::twa::prop_set arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa__prop_set,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "copy" "', argument " "2"" of type '" "spot::twa::prop_set""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "copy" "', argument " "2"" of type '" "spot::twa::prop_set""'");
    } else {
      spot::twa::prop_set * temp = reinterpret_cast< spot::twa::prop_set * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::copy((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_copy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "copy", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_copy__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_copy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_copy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'copy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::copy(spot::const_twa_ptr const &,spot::twa::prop_set,bool,unsigned int)\n"
    "    spot::copy(spot::const_twa_ptr const &,spot::twa::prop_set,bool)\n"
    "    spot::copy(spot::const_twa_ptr const &,spot::twa::prop_set)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_complete_here(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "complete_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      spot::complete_here(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_complete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "complete" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::complete((std::shared_ptr< spot::twa const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delay_branching_here(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delay_branching_here" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::delay_branching_here((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "degeneralize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "degeneralize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "degeneralize" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "degeneralize" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "degeneralize" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = spot::degeneralize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "degeneralize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "degeneralize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "degeneralize" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "degeneralize" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = spot::degeneralize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "degeneralize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "degeneralize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "degeneralize" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = spot::degeneralize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "degeneralize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "degeneralize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = spot::degeneralize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "degeneralize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::degeneralize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::degeneralize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::degeneralize((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "degeneralize", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_degeneralize__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_degeneralize__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_degeneralize__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_degeneralize__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_degeneralize__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_degeneralize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_degeneralize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'degeneralize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::degeneralize(spot::const_twa_graph_ptr const &,bool,bool,int,bool,bool,bool)\n"
    "    spot::degeneralize(spot::const_twa_graph_ptr const &,bool,bool,int,bool,bool)\n"
    "    spot::degeneralize(spot::const_twa_graph_ptr const &,bool,bool,int,bool)\n"
    "    spot::degeneralize(spot::const_twa_graph_ptr const &,bool,bool,int)\n"
    "    spot::degeneralize(spot::const_twa_graph_ptr const &,bool,bool)\n"
    "    spot::degeneralize(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::degeneralize(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_degeneralize_tba__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize_tba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize_tba" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "degeneralize_tba" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "degeneralize_tba" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "degeneralize_tba" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "degeneralize_tba" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "degeneralize_tba" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = spot::degeneralize_tba((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize_tba__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize_tba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize_tba" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "degeneralize_tba" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "degeneralize_tba" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "degeneralize_tba" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "degeneralize_tba" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = spot::degeneralize_tba((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize_tba__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize_tba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize_tba" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "degeneralize_tba" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "degeneralize_tba" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "degeneralize_tba" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = spot::degeneralize_tba((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize_tba__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize_tba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize_tba" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "degeneralize_tba" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "degeneralize_tba" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = spot::degeneralize_tba((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize_tba__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize_tba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize_tba" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "degeneralize_tba" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::degeneralize_tba((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize_tba__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize_tba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "degeneralize_tba" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::degeneralize_tba((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize_tba__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "degeneralize_tba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::degeneralize_tba((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_degeneralize_tba(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "degeneralize_tba", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_degeneralize_tba__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_degeneralize_tba__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_degeneralize_tba__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_degeneralize_tba__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_degeneralize_tba__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_degeneralize_tba__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_degeneralize_tba__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'degeneralize_tba'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::degeneralize_tba(spot::const_twa_graph_ptr const &,bool,bool,int,bool,bool,bool)\n"
    "    spot::degeneralize_tba(spot::const_twa_graph_ptr const &,bool,bool,int,bool,bool)\n"
    "    spot::degeneralize_tba(spot::const_twa_graph_ptr const &,bool,bool,int,bool)\n"
    "    spot::degeneralize_tba(spot::const_twa_graph_ptr const &,bool,bool,int)\n"
    "    spot::degeneralize_tba(spot::const_twa_graph_ptr const &,bool,bool)\n"
    "    spot::degeneralize_tba(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::degeneralize_tba(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_partial_degeneralize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partial_degeneralize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "partial_degeneralize" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "partial_degeneralize" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::partial_degeneralize((std::shared_ptr< spot::twa_graph const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partial_degeneralize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partial_degeneralize" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::partial_degeneralize(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partial_degeneralize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "partial_degeneralize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_partial_degeneralize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_partial_degeneralize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'partial_degeneralize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::partial_degeneralize(spot::const_twa_graph_ptr const &,spot::acc_cond::mark_t)\n"
    "    spot::partial_degeneralize(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_partially_degeneralizable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  SwigValueWrapper< std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > > > arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  spot::acc_cond::mark_t result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_partially_degeneralizable" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "is_partially_degeneralizable" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "is_partially_degeneralizable" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_std__vectorT_spot__acc_cond__mark_t_std__allocatorT_spot__acc_cond__mark_t_t_t,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "is_partially_degeneralizable" "', argument " "4"" of type '" "std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "is_partially_degeneralizable" "', argument " "4"" of type '" "std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > >""'");
    } else {
      std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > > * temp = reinterpret_cast< std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > > * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = spot::is_partially_degeneralizable((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,SWIG_STD_MOVE(arg4));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_partially_degeneralizable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::acc_cond::mark_t result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_partially_degeneralizable" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "is_partially_degeneralizable" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "is_partially_degeneralizable" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::is_partially_degeneralizable((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_partially_degeneralizable__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::acc_cond::mark_t result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_partially_degeneralizable" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "is_partially_degeneralizable" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::is_partially_degeneralizable((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_partially_degeneralizable__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::acc_cond::mark_t result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_partially_degeneralizable" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::is_partially_degeneralizable((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_partially_degeneralizable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_partially_degeneralizable", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_is_partially_degeneralizable__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_is_partially_degeneralizable__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_is_partially_degeneralizable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_is_partially_degeneralizable__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_partially_degeneralizable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_partially_degeneralizable(spot::const_twa_graph_ptr const &,bool,bool,std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > >)\n"
    "    spot::is_partially_degeneralizable(spot::const_twa_graph_ptr const &,bool,bool)\n"
    "    spot::is_partially_degeneralizable(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::is_partially_degeneralizable(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_propagate_marks_vector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::scc_info *arg2 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SwigValueWrapper< std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "propagate_marks_vector" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "propagate_marks_vector" "', argument " "2"" of type '" "spot::scc_info const *""'"); 
  }
  arg2 = reinterpret_cast< spot::scc_info * >(argp2);
  {
    try {
      result = spot::propagate_marks_vector((std::shared_ptr< spot::twa_graph const > const &)*arg1,(spot::scc_info const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > >(result)), SWIGTYPE_p_std__vectorT_spot__acc_cond__mark_t_std__allocatorT_spot__acc_cond__mark_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_propagate_marks_vector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  SwigValueWrapper< std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "propagate_marks_vector" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::propagate_marks_vector((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > >(result)), SWIGTYPE_p_std__vectorT_spot__acc_cond__mark_t_std__allocatorT_spot__acc_cond__mark_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_propagate_marks_vector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "propagate_marks_vector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_propagate_marks_vector__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_propagate_marks_vector__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'propagate_marks_vector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::propagate_marks_vector(spot::const_twa_graph_ptr const &,spot::scc_info const *)\n"
    "    spot::propagate_marks_vector(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_propagate_marks_here__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  spot::scc_info *arg2 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "propagate_marks_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "propagate_marks_here" "', argument " "2"" of type '" "spot::scc_info const *""'"); 
  }
  arg2 = reinterpret_cast< spot::scc_info * >(argp2);
  {
    try {
      spot::propagate_marks_here(*arg1,(spot::scc_info const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_propagate_marks_here__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "propagate_marks_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      spot::propagate_marks_here(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_propagate_marks_here(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "propagate_marks_here", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_propagate_marks_here__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_propagate_marks_here__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'propagate_marks_here'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::propagate_marks_here(spot::twa_graph_ptr &,spot::scc_info const *)\n"
    "    spot::propagate_marks_here(spot::twa_graph_ptr &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_tgba_determinize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  output_aborter *arg6 = (output_aborter *) 0 ;
  int arg7 ;
  bool arg8 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tgba_determinize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_determinize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tgba_determinize" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "tgba_determinize" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "tgba_determinize" "', argument " "6"" of type '" "output_aborter const *""'"); 
  }
  arg6 = reinterpret_cast< output_aborter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "tgba_determinize" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "tgba_determinize" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = spot::tgba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4,arg5,(output_aborter const *)arg6,arg7,arg8);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_determinize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  output_aborter *arg6 = (output_aborter *) 0 ;
  int arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tgba_determinize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_determinize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tgba_determinize" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "tgba_determinize" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "tgba_determinize" "', argument " "6"" of type '" "output_aborter const *""'"); 
  }
  arg6 = reinterpret_cast< output_aborter * >(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "tgba_determinize" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  {
    try {
      result = spot::tgba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4,arg5,(output_aborter const *)arg6,arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_determinize__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  output_aborter *arg6 = (output_aborter *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tgba_determinize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_determinize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tgba_determinize" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "tgba_determinize" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "tgba_determinize" "', argument " "6"" of type '" "output_aborter const *""'"); 
  }
  arg6 = reinterpret_cast< output_aborter * >(argp6);
  {
    try {
      result = spot::tgba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4,arg5,(output_aborter const *)arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_determinize__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tgba_determinize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_determinize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tgba_determinize" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "tgba_determinize" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = spot::tgba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_determinize__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tgba_determinize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_determinize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tgba_determinize" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::tgba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_determinize__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tgba_determinize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_determinize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::tgba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_determinize__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tgba_determinize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::tgba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_determinize__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::tgba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_determinize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "tgba_determinize", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_tgba_determinize__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_tgba_determinize__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_tgba_determinize__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_tgba_determinize__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_tgba_determinize__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_tgba_determinize__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_tgba_determinize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 8) {
    PyObject *retobj = _wrap_tgba_determinize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'tgba_determinize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::tgba_determinize(spot::const_twa_graph_ptr const &,bool,bool,bool,bool,output_aborter const *,int,bool)\n"
    "    spot::tgba_determinize(spot::const_twa_graph_ptr const &,bool,bool,bool,bool,output_aborter const *,int)\n"
    "    spot::tgba_determinize(spot::const_twa_graph_ptr const &,bool,bool,bool,bool,output_aborter const *)\n"
    "    spot::tgba_determinize(spot::const_twa_graph_ptr const &,bool,bool,bool,bool)\n"
    "    spot::tgba_determinize(spot::const_twa_graph_ptr const &,bool,bool,bool)\n"
    "    spot::tgba_determinize(spot::const_twa_graph_ptr const &,bool,bool)\n"
    "    spot::tgba_determinize(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::tgba_determinize(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_dot__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_dot" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_dot" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (std::ostream *) &spot::print_dot(*arg1,(std::shared_ptr< spot::twa const > const &)*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_dot__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_dot" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::print_dot(*arg1,(std::shared_ptr< spot::twa const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_dot__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::aig_ptr arg2 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__aig_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_dot" "', argument " "2"" of type '" "spot::aig_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::aig_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::aig_ptr * >(argp2);
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_dot" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (std::ostream *) &spot::print_dot(*arg1,SWIG_STD_MOVE(arg2),(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_dot__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::aig_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__aig_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_dot" "', argument " "2"" of type '" "spot::aig_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::aig_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::aig_ptr * >(argp2);
  }
  {
    try {
      result = (std::ostream *) &spot::print_dot(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dualize(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dualize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::dualize((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_emptiness_check_result__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::option_map arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::emptiness_check_result *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_emptiness_check_result" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_emptiness_check_result" "', argument " "2"" of type '" "spot::option_map""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_emptiness_check_result" "', argument " "2"" of type '" "spot::option_map""'");
    } else {
      spot::option_map * temp = reinterpret_cast< spot::option_map * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::emptiness_check_result *)new spot::emptiness_check_result((spot::const_twa_ptr const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check_result > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check_result >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_emptiness_check_result__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  spot::emptiness_check_result *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_emptiness_check_result" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::emptiness_check_result *)new spot::emptiness_check_result((spot::const_twa_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check_result > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check_result >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_emptiness_check_result(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_emptiness_check_result", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_emptiness_check_result__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_emptiness_check_result__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_emptiness_check_result'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::emptiness_check_result::emptiness_check_result(spot::const_twa_ptr const &,spot::option_map)\n"
    "    spot::emptiness_check_result::emptiness_check_result(spot::const_twa_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_emptiness_check_result(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check_result *arg1 = (spot::emptiness_check_result *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_result > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_result > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_emptiness_check_result" "', argument " "1"" of type '" "spot::emptiness_check_result *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::emptiness_check_result > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_result_accepting_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check_result *arg1 = (spot::emptiness_check_result *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_result > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_result > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_run_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_result_accepting_run" "', argument " "1"" of type '" "spot::emptiness_check_result *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::emptiness_check_result > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->accepting_run();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_result_automaton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check_result *arg1 = (spot::emptiness_check_result *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_result const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_result const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::const_twa_ptr *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_result_automaton" "', argument " "1"" of type '" "spot::emptiness_check_result const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check_result > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::const_twa_ptr *) &((spot::emptiness_check_result const *)arg1)->automaton();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr< const spot::twa > *smartresult = *result ? new std::shared_ptr< const spot::twa >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_result_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check_result *arg1 = (spot::emptiness_check_result *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_result const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_result const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::option_map *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_result_options" "', argument " "1"" of type '" "spot::emptiness_check_result const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check_result > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::option_map *) &((spot::emptiness_check_result const *)arg1)->options();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__option_map, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_result_parse_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check_result *arg1 = (spot::emptiness_check_result *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_result > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_result > *smartarg1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "emptiness_check_result_parse_options", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_result_parse_options" "', argument " "1"" of type '" "spot::emptiness_check_result *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::emptiness_check_result > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "emptiness_check_result_parse_options" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->parse_options(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_result_statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check_result *arg1 = (spot::emptiness_check_result *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_result const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_result const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned_statistics *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_result_statistics" "', argument " "1"" of type '" "spot::emptiness_check_result const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check_result > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check_result > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_result * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned_statistics *)((spot::emptiness_check_result const *)arg1)->statistics();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_statistics, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *emptiness_check_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *emptiness_check_result_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_emptiness_check(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check *arg1 = (spot::emptiness_check *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check > tempshared1 ;
  std::shared_ptr< spot::emptiness_check > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_emptiness_check" "', argument " "1"" of type '" "spot::emptiness_check *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_automaton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check *arg1 = (spot::emptiness_check *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::const_twa_ptr *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_automaton" "', argument " "1"" of type '" "spot::emptiness_check const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::const_twa_ptr *) &((spot::emptiness_check const *)arg1)->automaton();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr< const spot::twa > *smartresult = *result ? new std::shared_ptr< const spot::twa >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check *arg1 = (spot::emptiness_check *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::option_map *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_options" "', argument " "1"" of type '" "spot::emptiness_check const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::option_map *) &((spot::emptiness_check const *)arg1)->options();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__option_map, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_parse_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check *arg1 = (spot::emptiness_check *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check > tempshared1 ;
  std::shared_ptr< spot::emptiness_check > *smartarg1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  char *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "emptiness_check_parse_options", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_parse_options" "', argument " "1"" of type '" "spot::emptiness_check *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "emptiness_check_parse_options" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)(arg1)->parse_options(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_safe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check *arg1 = (spot::emptiness_check *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_safe" "', argument " "1"" of type '" "spot::emptiness_check const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (bool)((spot::emptiness_check const *)arg1)->safe();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_check(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check *arg1 = (spot::emptiness_check *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check > tempshared1 ;
  std::shared_ptr< spot::emptiness_check > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::emptiness_check_result_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_check" "', argument " "1"" of type '" "spot::emptiness_check *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->check();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check_result > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check_result >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_result_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check *arg1 = (spot::emptiness_check *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned_statistics *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_statistics" "', argument " "1"" of type '" "spot::emptiness_check const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned_statistics *)((spot::emptiness_check const *)arg1)->statistics();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_statistics, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_emptiness_check_statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check *arg1 = (spot::emptiness_check *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  ec_statistics *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_emptiness_check_statistics" "', argument " "1"" of type '" "spot::emptiness_check const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (ec_statistics *)((spot::emptiness_check const *)arg1)->emptiness_check_statistics();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ec_statistics, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_print_stats(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check *arg1 = (spot::emptiness_check *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "emptiness_check_print_stats", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_print_stats" "', argument " "1"" of type '" "spot::emptiness_check const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "emptiness_check_print_stats" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "emptiness_check_print_stats" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::emptiness_check const *)arg1)->print_stats(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_options_updated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check *arg1 = (spot::emptiness_check *) 0 ;
  spot::option_map *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check > tempshared1 ;
  std::shared_ptr< spot::emptiness_check > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "emptiness_check_options_updated", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_options_updated" "', argument " "1"" of type '" "spot::emptiness_check *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::emptiness_check > * >(argp1);
      arg1 = const_cast< spot::emptiness_check * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "emptiness_check_options_updated" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "emptiness_check_options_updated" "', argument " "2"" of type '" "spot::option_map const &""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  {
    try {
      (arg1)->options_updated((spot::option_map const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *emptiness_check_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_emptiness_check_instantiator_instantiate(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check_instantiator *arg1 = (spot::emptiness_check_instantiator *) 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_instantiator const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_instantiator const > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  spot::emptiness_check_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "emptiness_check_instantiator_instantiate", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_instantiator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_instantiator_instantiate" "', argument " "1"" of type '" "spot::emptiness_check_instantiator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "emptiness_check_instantiator_instantiate" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = ((spot::emptiness_check_instantiator const *)arg1)->instantiate((spot::const_twa_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_instantiator_options__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::emptiness_check_instantiator *arg1 = (spot::emptiness_check_instantiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_instantiator const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_instantiator const > *smartarg1 = 0 ;
  spot::option_map *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_instantiator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_instantiator_options" "', argument " "1"" of type '" "spot::emptiness_check_instantiator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::option_map *) &((spot::emptiness_check_instantiator const *)arg1)->options();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__option_map, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_instantiator_options__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::emptiness_check_instantiator *arg1 = (spot::emptiness_check_instantiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_instantiator > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_instantiator > *smartarg1 = 0 ;
  spot::option_map *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_instantiator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_instantiator_options" "', argument " "1"" of type '" "spot::emptiness_check_instantiator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::emptiness_check_instantiator > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::option_map *) &(arg1)->options();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__option_map, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_instantiator_options(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "emptiness_check_instantiator_options", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_emptiness_check_instantiator_options__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_emptiness_check_instantiator_options__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'emptiness_check_instantiator_options'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::emptiness_check_instantiator::options() const\n"
    "    spot::emptiness_check_instantiator::options()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_emptiness_check_instantiator_min_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check_instantiator *arg1 = (spot::emptiness_check_instantiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_instantiator const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_instantiator const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_instantiator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_instantiator_min_sets" "', argument " "1"" of type '" "spot::emptiness_check_instantiator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::emptiness_check_instantiator const *)arg1)->min_sets();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_emptiness_check_instantiator_max_sets(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check_instantiator *arg1 = (spot::emptiness_check_instantiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_instantiator const > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_instantiator const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_instantiator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "emptiness_check_instantiator_max_sets" "', argument " "1"" of type '" "spot::emptiness_check_instantiator const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::emptiness_check_instantiator const *)arg1)->max_sets();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_emptiness_check_instantiator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::emptiness_check_instantiator *arg1 = (spot::emptiness_check_instantiator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::emptiness_check_instantiator > tempshared1 ;
  std::shared_ptr< spot::emptiness_check_instantiator > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_instantiator_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_emptiness_check_instantiator" "', argument " "1"" of type '" "spot::emptiness_check_instantiator *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::emptiness_check_instantiator > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::emptiness_check_instantiator > * >(argp1);
      arg1 = const_cast< spot::emptiness_check_instantiator * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *emptiness_check_instantiator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_instantiator_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_make_emptiness_check_instantiator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  char **arg2 = (char **) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  char *temp2 ;
  PyObject *swig_obj[1] ;
  spot::emptiness_check_instantiator_ptr result;
  
  {
    arg2 = &temp2;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_emptiness_check_instantiator" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = spot::make_emptiness_check_instantiator((char const *)arg1,(char const **)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check_instantiator > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check_instantiator >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_instantiator_t, SWIG_POINTER_OWN);
  }
  {
    PyObject *obj = SWIG_FromCharPtr(*arg2);
    if (!resultobj) {
      resultobj = obj;
      //# If the function returns null_ptr (i.e. Py_None), we
      //# don't want to override it with OUTPUT as in the
      //# default implementation of t_output_helper.
      // } else if (resultobj == Py_None) {
      //   Py_DECREF(resultobj);
      //   resultobj = obj;
    } else {
      if (!PyList_Check(resultobj)) {
        PyObject *o2 = resultobj;
        resultobj = PyList_New(1);
        PyList_SetItem(resultobj, 0, o2);
      }
      PyList_Append(resultobj, obj);
      Py_DECREF(obj);
    }
    
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_prefix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  spot::twa_run::steps *arg2 = (spot::twa_run::steps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_run_prefix_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_prefix_set" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_run_prefix_set" "', argument " "2"" of type '" "spot::twa_run::steps *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_run::steps * >(argp2);
  if (arg1) (arg1)->prefix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_prefix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_run::steps *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_prefix_get" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::twa_run::steps *)& ((arg1)->prefix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_cycle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  spot::twa_run::steps *arg2 = (spot::twa_run::steps *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_run_cycle_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_cycle_set" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_run_cycle_set" "', argument " "2"" of type '" "spot::twa_run::steps *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_run::steps * >(argp2);
  if (arg1) (arg1)->cycle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_cycle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_run::steps *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_cycle_get" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::twa_run::steps *)& ((arg1)->cycle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_aut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_run_aut_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_aut_set" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_run_aut_set" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  if (arg1) (arg1)->aut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_aut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::const_twa_ptr *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_aut_get" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::const_twa_ptr *) & ((arg1)->aut);
  {
    std::shared_ptr< const spot::twa > *smartresult = *result ? new std::shared_ptr< const spot::twa >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_twa_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_run" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_run__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  spot::twa_run *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_run" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::twa_run *)new spot::twa_run((spot::const_twa_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_run__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run const > tempshared1 ;
  spot::twa_run *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_run" "', argument " "1"" of type '" "spot::twa_run const &""'");
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_twa_run" "', argument " "1"" of type '" "spot::twa_run const &""'"); 
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      arg1 = const_cast< spot::twa_run * >(reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1)->get());
    }
  }
  {
    try {
      result = (spot::twa_run *)new spot::twa_run((spot::twa_run const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_run(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_twa_run", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_twa_run__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_twa_run__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_twa_run'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_run::twa_run(spot::const_twa_ptr const &)\n"
    "    spot::twa_run::twa_run(spot::twa_run const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_run_ensure_non_empty_cycle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run const > tempshared1 ;
  std::shared_ptr< spot::twa_run const > *smartarg1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_run_ensure_non_empty_cycle", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_ensure_non_empty_cycle" "', argument " "1"" of type '" "spot::twa_run const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_run_ensure_non_empty_cycle" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      ((spot::twa_run const *)arg1)->ensure_non_empty_cycle((char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_reduce(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run const > tempshared1 ;
  std::shared_ptr< spot::twa_run const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_run_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_reduce" "', argument " "1"" of type '" "spot::twa_run const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa_run const *)arg1)->reduce();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_project__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_run_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_project" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_run_project" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "twa_run_project" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (arg1)->project((spot::const_twa_ptr const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_project__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  spot::twa_run_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_project" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_run_project" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (arg1)->project((spot::const_twa_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_project(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_run_project", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_run_project__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_twa_run_project__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_run_project'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_run::project(spot::const_twa_ptr const &,bool)\n"
    "    spot::twa_run::project(spot::const_twa_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_run_replay__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  std::ostream *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run const > tempshared1 ;
  std::shared_ptr< spot::twa_run const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_replay" "', argument " "1"" of type '" "spot::twa_run const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_run_replay" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_run_replay" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "twa_run_replay" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (bool)((spot::twa_run const *)arg1)->replay(*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_replay__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run const > tempshared1 ;
  std::shared_ptr< spot::twa_run const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_replay" "', argument " "1"" of type '" "spot::twa_run const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_run_replay" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_run_replay" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (bool)((spot::twa_run const *)arg1)->replay(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_replay(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_run_replay", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_run_replay__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_twa_run_replay__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_run_replay'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_run::replay(std::ostream &,bool) const\n"
    "    spot::twa_run::replay(std::ostream &) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_run_highlight(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_run_highlight", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_highlight" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_run_highlight" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      (arg1)->highlight(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_as_twa__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run const > tempshared1 ;
  std::shared_ptr< spot::twa_run const > *smartarg1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_as_twa" "', argument " "1"" of type '" "spot::twa_run const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_run_as_twa" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = ((spot::twa_run const *)arg1)->as_twa(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_as_twa__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run const > tempshared1 ;
  std::shared_ptr< spot::twa_run const > *smartarg1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run_as_twa" "', argument " "1"" of type '" "spot::twa_run const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa_run const *)arg1)->as_twa();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_run_as_twa(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_run_as_twa", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_twa_run_as_twa__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_run_as_twa__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_run_as_twa'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_run::as_twa(bool) const\n"
    "    spot::twa_run::as_twa() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_run___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run *arg1 = (spot::twa_run *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_run > tempshared1 ;
  std::shared_ptr< spot::twa_run > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_run___str__" "', argument " "1"" of type '" "spot::twa_run *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_run > * >(argp1);
      arg1 = const_cast< spot::twa_run * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = spot_twa_run___str__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_run_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_run_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_step_s_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run::step *arg1 = (spot::twa_run::step *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "step_s_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_run__step, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "step_s_set" "', argument " "1"" of type '" "spot::twa_run::step *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_run::step * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "step_s_set" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  if (arg1) (arg1)->s = (spot::state const *)arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_step_s_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run::step *arg1 = (spot::twa_run::step *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_run__step, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "step_s_get" "', argument " "1"" of type '" "spot::twa_run::step *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_run::step * >(argp1);
  result = (spot::state *) ((arg1)->s);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_step_label_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run::step *arg1 = (spot::twa_run::step *) 0 ;
  bdd *arg2 = (bdd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "step_label_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_run__step, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "step_label_set" "', argument " "1"" of type '" "spot::twa_run::step *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_run::step * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_bdd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "step_label_set" "', argument " "2"" of type '" "bdd *""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  if (arg1) (arg1)->label = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_step_label_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run::step *arg1 = (spot::twa_run::step *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bdd *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_run__step, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "step_label_get" "', argument " "1"" of type '" "spot::twa_run::step *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_run::step * >(argp1);
  result = (bdd *)& ((arg1)->label);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bdd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_step_acc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run::step *arg1 = (spot::twa_run::step *) 0 ;
  spot::acc_cond::mark_t *arg2 = (spot::acc_cond::mark_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "step_acc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_run__step, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "step_acc_set" "', argument " "1"" of type '" "spot::twa_run::step *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_run::step * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "step_acc_set" "', argument " "2"" of type '" "spot::acc_cond::mark_t *""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
  if (arg1) (arg1)->acc = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_step_acc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run::step *arg1 = (spot::twa_run::step *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_run__step, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "step_acc_get" "', argument " "1"" of type '" "spot::twa_run::step *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_run::step * >(argp1);
  result = (spot::acc_cond::mark_t *)& ((arg1)->acc);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_step__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::state *arg1 = (spot::state *) 0 ;
  bdd arg2 ;
  spot::acc_cond::mark_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  spot::twa_run::step *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_step" "', argument " "1"" of type '" "spot::state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_step" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_step" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_step" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_step" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (spot::twa_run::step *)new spot::twa_run::step((spot::state const *)arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_run__step, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_step__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::twa_run::step *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::twa_run::step *)new spot::twa_run::step();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_run__step, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_step(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_step", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_step__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_step__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_step'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_run::step::step(spot::state const *,bdd,spot::acc_cond::mark_t)\n"
    "    spot::twa_run::step::step()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_run::step *arg1 = (spot::twa_run::step *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_run__step, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_step" "', argument " "1"" of type '" "spot::twa_run::step *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_run::step * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *step_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__twa_run__step, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *step_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_list_step_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_iterator" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_list_Sl_spot_twa_run_step_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___nonzero__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = (bool)std_list_Sl_spot_twa_run_step_Sg____nonzero__((std::list< spot::twa_run::step > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___bool__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = (bool)std_list_Sl_spot_twa_run_step_Sg____bool__((std::list< spot::twa_run::step > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< spot::twa_run::step >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___len__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = std_list_Sl_spot_twa_run_step_Sg____len__((std::list< spot::twa_run::step > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::difference_type arg2 ;
  std::list< spot::twa_run::step >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_step___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___getslice__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_step___getslice__" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg2 = static_cast< std::list< spot::twa_run::step >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "list_step___getslice__" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg3 = static_cast< std::list< spot::twa_run::step >::difference_type >(val3);
  {
    try {
      try {
        result = (std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *)std_list_Sl_spot_twa_run_step_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::difference_type arg2 ;
  std::list< spot::twa_run::step >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___setslice__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_step___setslice__" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg2 = static_cast< std::list< spot::twa_run::step >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "list_step___setslice__" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg3 = static_cast< std::list< spot::twa_run::step >::difference_type >(val3);
  {
    try {
      try {
        std_list_Sl_spot_twa_run_step_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::difference_type arg2 ;
  std::list< spot::twa_run::step >::difference_type arg3 ;
  std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___setslice__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_step___setslice__" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg2 = static_cast< std::list< spot::twa_run::step >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "list_step___setslice__" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg3 = static_cast< std::list< spot::twa_run::step >::difference_type >(val3);
  {
    std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *ptr = (std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "list_step___setslice__" "', argument " "4"" of type '" "std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step___setslice__" "', argument " "4"" of type '" "std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_list_Sl_spot_twa_run_step_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_step___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_list_step___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_list_step___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_step___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< spot::twa_run::step >::__setslice__(std::list< spot::twa_run::step >::difference_type,std::list< spot::twa_run::step >::difference_type)\n"
    "    std::list< spot::twa_run::step >::__setslice__(std::list< spot::twa_run::step >::difference_type,std::list< spot::twa_run::step >::difference_type,std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_step___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::difference_type arg2 ;
  std::list< spot::twa_run::step >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_step___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___delslice__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_step___delslice__" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg2 = static_cast< std::list< spot::twa_run::step >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "list_step___delslice__" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg3 = static_cast< std::list< spot::twa_run::step >::difference_type >(val3);
  {
    try {
      try {
        std_list_Sl_spot_twa_run_step_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___delitem__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_step___delitem__" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg2 = static_cast< std::list< spot::twa_run::step >::difference_type >(val2);
  {
    try {
      try {
        std_list_Sl_spot_twa_run_step_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___getitem__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_step___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *)std_list_Sl_spot_twa_run_step_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___setitem__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_step___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *ptr = (std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "list_step___setitem__" "', argument " "3"" of type '" "std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step___setitem__" "', argument " "3"" of type '" "std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_list_Sl_spot_twa_run_step_Sg____setitem____SWIG_0(arg1,arg2,(std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___setitem__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_step___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_list_Sl_spot_twa_run_step_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___delitem__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_step___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_list_Sl_spot_twa_run_step_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_step___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_list_step___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_list_step___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_step___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< spot::twa_run::step >::__delitem__(std::list< spot::twa_run::step >::difference_type)\n"
    "    std::list< spot::twa_run::step >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_step___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::list< spot::twa_run::step >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___getitem__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_step___getitem__" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg2 = static_cast< std::list< spot::twa_run::step >::difference_type >(val2);
  {
    try {
      try {
        result = (std::list< spot::twa_run::step >::value_type *) &std_list_Sl_spot_twa_run_step_Sg____getitem____SWIG_1((std::list< spot::twa_run::step > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_run__step, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::list< spot::twa_run::step >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_step___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_list_step___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_list_step___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_step___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< spot::twa_run::step >::__getitem__(PySliceObject *)\n"
    "    std::list< spot::twa_run::step >::__getitem__(std::list< spot::twa_run::step >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_step___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::difference_type arg2 ;
  std::list< spot::twa_run::step >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step___setitem__" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_step___setitem__" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::difference_type""'");
  } 
  arg2 = static_cast< std::list< spot::twa_run::step >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__twa_run__step,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "list_step___setitem__" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step___setitem__" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< spot::twa_run::step >::value_type * >(argp3);
  {
    try {
      try {
        std_list_Sl_spot_twa_run_step_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(spot::twa_run::step const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_step___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_list_step___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_list_step___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_list_step___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_step___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< spot::twa_run::step >::__setitem__(PySliceObject *,std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > const &)\n"
    "    std::list< spot::twa_run::step >::__setitem__(PySliceObject *)\n"
    "    std::list< spot::twa_run::step >::__setitem__(std::list< spot::twa_run::step >::difference_type,std::list< spot::twa_run::step >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_step_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< spot::twa_run::step >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_pop" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      try {
        result = std_list_Sl_spot_twa_run_step_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::list< spot::twa_run::step >::value_type(result)), SWIGTYPE_p_spot__twa_run__step, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_step_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_append" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa_run__step,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "list_step_append" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step_append" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< spot::twa_run::step >::value_type * >(argp2);
  {
    try {
      std_list_Sl_spot_twa_run_step_Sg__append(arg1,(spot::twa_run::step const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_list_step__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::list< spot::twa_run::step > *)new std::list< spot::twa_run::step >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_list_step__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::list< spot::twa_run::step > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *ptr = (std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_list_step" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_list_step" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::list< spot::twa_run::step > *)new std::list< spot::twa_run::step >((std::list< spot::twa_run::step > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_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_list_step_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_empty" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = (bool)((std::list< spot::twa_run::step > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< spot::twa_run::step >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_size" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = ((std::list< spot::twa_run::step > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_step_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_swap" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "list_step_swap" "', argument " "2"" of type '" "std::list< spot::twa_run::step > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step_swap" "', argument " "2"" of type '" "std::list< spot::twa_run::step > &""'"); 
  }
  arg2 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< spot::twa_run::step >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_begin" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< spot::twa_run::step >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< spot::twa_run::step >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_end" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< spot::twa_run::step >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< spot::twa_run::step >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_rbegin" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< spot::twa_run::step >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< spot::twa_run::step >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_rend" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< spot::twa_run::step >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_clear" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< spot::twa_run::step > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_get_allocator" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = ((std::list< spot::twa_run::step > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::list< spot::twa_run::step >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_spot__twa_run__step_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_list_step__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::list< spot::twa_run::step > *result = 0 ;
  
  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_list_step" "', argument " "1"" of type '" "std::list< spot::twa_run::step >::size_type""'");
  } 
  arg1 = static_cast< std::list< spot::twa_run::step >::size_type >(val1);
  {
    try {
      result = (std::list< spot::twa_run::step > *)new std::list< spot::twa_run::step >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_pop_back" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_resize" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_step_resize" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::size_type""'");
  } 
  arg2 = static_cast< std::list< spot::twa_run::step >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::list< spot::twa_run::step >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_erase" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(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 '" "list_step_erase" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< spot::twa_run::step >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< spot::twa_run::step >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_step_erase" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::iterator""'");
    }
  }
  {
    try {
      result = std_list_Sl_spot_twa_run_step_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< spot::twa_run::step >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::iterator arg2 ;
  std::list< spot::twa_run::step >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::list< spot::twa_run::step >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_erase" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(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 '" "list_step_erase" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< spot::twa_run::step >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< spot::twa_run::step >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_step_erase" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::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 '" "list_step_erase" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< spot::twa_run::step >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< spot::twa_run::step >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_step_erase" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::iterator""'");
    }
  }
  {
    try {
      result = std_list_Sl_spot_twa_run_step_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< spot::twa_run::step >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_step_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_list_step_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_list_step_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_step_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< spot::twa_run::step >::erase(std::list< spot::twa_run::step >::iterator)\n"
    "    std::list< spot::twa_run::step >::erase(std::list< spot::twa_run::step >::iterator,std::list< spot::twa_run::step >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_list_step__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step >::size_type arg1 ;
  std::list< spot::twa_run::step >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::list< spot::twa_run::step > *result = 0 ;
  
  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_list_step" "', argument " "1"" of type '" "std::list< spot::twa_run::step >::size_type""'");
  } 
  arg1 = static_cast< std::list< spot::twa_run::step >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa_run__step,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_list_step" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_list_step" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< spot::twa_run::step >::value_type * >(argp2);
  {
    try {
      result = (std::list< spot::twa_run::step > *)new std::list< spot::twa_run::step >(arg1,(std::list< spot::twa_run::step >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_list_step(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_list_step", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_list_step__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_list_step__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_list_step__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_list_step__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_list_step'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< spot::twa_run::step >::list()\n"
    "    std::list< spot::twa_run::step >::list(std::list< spot::twa_run::step > const &)\n"
    "    std::list< spot::twa_run::step >::list(std::list< spot::twa_run::step >::size_type)\n"
    "    std::list< spot::twa_run::step >::list(std::list< spot::twa_run::step >::size_type,std::list< spot::twa_run::step >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_step_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_step_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_push_back" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa_run__step,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "list_step_push_back" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step_push_back" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< spot::twa_run::step >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::list< spot::twa_run::step >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< spot::twa_run::step >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_front" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = (std::list< spot::twa_run::step >::value_type *) &((std::list< spot::twa_run::step > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_run__step, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::list< spot::twa_run::step >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< spot::twa_run::step >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_back" "', argument " "1"" of type '" "std::list< spot::twa_run::step > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      result = (std::list< spot::twa_run::step >::value_type *) &((std::list< spot::twa_run::step > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_run__step, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::list< spot::twa_run::step >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::size_type arg2 ;
  std::list< spot::twa_run::step >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_step_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_assign" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_step_assign" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::size_type""'");
  } 
  arg2 = static_cast< std::list< spot::twa_run::step >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__twa_run__step,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "list_step_assign" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step_assign" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< spot::twa_run::step >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::list< spot::twa_run::step >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::size_type arg2 ;
  std::list< spot::twa_run::step >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_resize" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_step_resize" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::size_type""'");
  } 
  arg2 = static_cast< std::list< spot::twa_run::step >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__twa_run__step,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "list_step_resize" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step_resize" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< spot::twa_run::step >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::list< spot::twa_run::step >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_step_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_list_step_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_list_step_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_step_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< spot::twa_run::step >::resize(std::list< spot::twa_run::step >::size_type)\n"
    "    std::list< spot::twa_run::step >::resize(std::list< spot::twa_run::step >::size_type,std::list< spot::twa_run::step >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_step_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::iterator arg2 ;
  std::list< spot::twa_run::step >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::list< spot::twa_run::step >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_insert" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(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 '" "list_step_insert" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< spot::twa_run::step >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< spot::twa_run::step >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_step_insert" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__twa_run__step,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "list_step_insert" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step_insert" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< spot::twa_run::step >::value_type * >(argp3);
  {
    try {
      result = std_list_Sl_spot_twa_run_step_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(spot::twa_run::step const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< spot::twa_run::step >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::iterator arg2 ;
  std::list< spot::twa_run::step >::size_type arg3 ;
  std::list< spot::twa_run::step >::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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_insert" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(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 '" "list_step_insert" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< spot::twa_run::step >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< spot::twa_run::step >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_step_insert" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "list_step_insert" "', argument " "3"" of type '" "std::list< spot::twa_run::step >::size_type""'");
  } 
  arg3 = static_cast< std::list< spot::twa_run::step >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_spot__twa_run__step,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "list_step_insert" "', argument " "4"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step_insert" "', argument " "4"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::list< spot::twa_run::step >::value_type * >(argp4);
  {
    try {
      std_list_Sl_spot_twa_run_step_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(spot::twa_run::step const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_step_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_list_step_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_list_step_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_step_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< spot::twa_run::step >::insert(std::list< spot::twa_run::step >::iterator,std::list< spot::twa_run::step >::value_type const &)\n"
    "    std::list< spot::twa_run::step >::insert(std::list< spot::twa_run::step >::iterator,std::list< spot::twa_run::step >::size_type,std::list< spot::twa_run::step >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_step_pop_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_pop_front" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      (arg1)->pop_front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_push_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  std::list< spot::twa_run::step >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_step_push_front", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_push_front" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__twa_run__step,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "list_step_push_front" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_step_push_front" "', argument " "2"" of type '" "std::list< spot::twa_run::step >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< spot::twa_run::step >::value_type * >(argp2);
  {
    try {
      (arg1)->push_front((std::list< spot::twa_run::step >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_step_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_step_reverse" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      (arg1)->reverse();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_list_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< spot::twa_run::step > *arg1 = (std::list< spot::twa_run::step > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_list_step" "', argument " "1"" of type '" "std::list< spot::twa_run::step > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< spot::twa_run::step > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *list_step_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *list_step_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_couvreur99__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::option_map arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::emptiness_check_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "couvreur99" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "couvreur99" "', argument " "2"" of type '" "spot::option_map""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "couvreur99" "', argument " "2"" of type '" "spot::option_map""'");
    } else {
      spot::option_map * temp = reinterpret_cast< spot::option_map * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::couvreur99((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_couvreur99__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  spot::emptiness_check_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "couvreur99" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::couvreur99((std::shared_ptr< spot::twa const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_couvreur99(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "couvreur99", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_couvreur99__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_couvreur99__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'couvreur99'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::couvreur99(spot::const_twa_ptr const &,spot::option_map)\n"
    "    spot::couvreur99(spot::const_twa_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_generic_emptiness_check(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_emptiness_check" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::generic_emptiness_check((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_accepting_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_run_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_accepting_run" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::generic_accepting_run((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_run > *smartresult = result ? new std::shared_ptr<  spot::twa_run >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_emptiness_check_for_scc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_emptiness_check_for_scc" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "generic_emptiness_check_for_scc" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_emptiness_check_for_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)spot::generic_emptiness_check_for_scc((spot::scc_info const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_emptiness_check_for_scc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "generic_emptiness_check_for_scc" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "generic_emptiness_check_for_scc" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "generic_emptiness_check_for_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "generic_emptiness_check_for_scc" "', argument " "3"" of type '" "spot::acc_cond const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "generic_emptiness_check_for_scc" "', argument " "3"" of type '" "spot::acc_cond const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond * >(argp3);
  {
    try {
      result = (bool)spot::generic_emptiness_check_for_scc((spot::scc_info const &)*arg1,arg2,(spot::acc_cond const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_emptiness_check_for_scc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "generic_emptiness_check_for_scc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_generic_emptiness_check_for_scc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_generic_emptiness_check_for_scc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'generic_emptiness_check_for_scc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::generic_emptiness_check_for_scc(spot::scc_info const &,unsigned int)\n"
    "    spot::generic_emptiness_check_for_scc(spot::scc_info const &,unsigned int,spot::acc_cond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_generic_emptiness_check_select_version__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  
  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 '" "generic_emptiness_check_select_version" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      spot::generic_emptiness_check_select_version((char const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_emptiness_check_select_version__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      spot::generic_emptiness_check_select_version();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_generic_emptiness_check_select_version(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "generic_emptiness_check_select_version", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_generic_emptiness_check_select_version__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_generic_emptiness_check_select_version__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'generic_emptiness_check_select_version'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::generic_emptiness_check_select_version(char const *)\n"
    "    spot::generic_emptiness_check_select_version()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_accepting_transitions_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond arg3 ;
  spot::acc_cond::mark_t arg4 ;
  std::vector< bool,std::allocator< bool > > *arg5 = 0 ;
  bitvect *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "accepting_transitions_scc", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "accepting_transitions_scc" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "accepting_transitions_scc" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "accepting_transitions_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "accepting_transitions_scc" "', argument " "3"" of type '" "spot::acc_cond const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "accepting_transitions_scc" "', argument " "3"" of type '" "spot::acc_cond const""'");
    } else {
      spot::acc_cond * temp = reinterpret_cast< spot::acc_cond * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "accepting_transitions_scc" "', argument " "4"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "accepting_transitions_scc" "', argument " "4"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "accepting_transitions_scc" "', argument " "5"" of type '" "std::vector< bool,std::allocator< bool > > &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "accepting_transitions_scc" "', argument " "5"" of type '" "std::vector< bool,std::allocator< bool > > &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< bool,std::allocator< bool > > * >(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_bitvect,  0  | 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "accepting_transitions_scc" "', argument " "6"" of type '" "bitvect const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "accepting_transitions_scc" "', argument " "6"" of type '" "bitvect const &""'"); 
  }
  arg6 = reinterpret_cast< bitvect * >(argp6);
  {
    try {
      result = (bool)spot::accepting_transitions_scc((spot::scc_info const &)*arg1,arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),*arg5,(bitvect const &)*arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_accepting_transitions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::acc_cond arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< bool,std::allocator< bool > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "accepting_transitions", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "accepting_transitions" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "accepting_transitions" "', argument " "2"" of type '" "spot::acc_cond""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "accepting_transitions" "', argument " "2"" of type '" "spot::acc_cond""'");
    } else {
      spot::acc_cond * temp = reinterpret_cast< spot::acc_cond * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::accepting_transitions(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_lbtt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_lbtt" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_lbtt" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_lbtt" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_lbtt" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (std::ostream *) &spot::print_lbtt(*arg1,(std::shared_ptr< spot::twa const > const &)*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_lbtt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_lbtt" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_lbtt" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_lbtt" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::print_lbtt(*arg1,(std::shared_ptr< spot::twa const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_lbtt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_lbtt", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_lbtt__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_lbtt__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_lbtt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_lbtt(std::ostream &,spot::const_twa_ptr const &,char const *)\n"
    "    spot::print_lbtt(std::ostream &,spot::const_twa_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ltl_to_taa__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::taa_tgba_formula_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_taa" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_taa" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ltl_to_taa" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::ltl_to_taa(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::taa_tgba_formula > *smartresult = result ? new std::shared_ptr<  spot::taa_tgba_formula >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_formula_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_taa__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  spot::taa_tgba_formula_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_taa" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_taa" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::ltl_to_taa(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::taa_tgba_formula > *smartresult = result ? new std::shared_ptr<  spot::taa_tgba_formula >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__taa_tgba_formula_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_taa(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ltl_to_taa", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_ltl_to_taa__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_ltl_to_taa__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ltl_to_taa'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::ltl_to_taa(spot::formula,spot::bdd_dict_ptr const &,bool)\n"
    "    spot::ltl_to_taa(spot::formula,spot::bdd_dict_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ltl_to_tgba_fm__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  spot::atomic_prop_set *arg7 = (spot::atomic_prop_set *) 0 ;
  spot::tl_simplifier *arg8 = (spot::tl_simplifier *) 0 ;
  bool arg9 ;
  output_aborter *arg10 = (output_aborter *) 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 10) || (nobjs > 10)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_tgba_fm" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_tgba_fm" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ltl_to_tgba_fm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ltl_to_tgba_fm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ltl_to_tgba_fm" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ltl_to_tgba_fm" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ltl_to_tgba_fm" "', argument " "7"" of type '" "spot::atomic_prop_set const *""'"); 
  }
  arg7 = reinterpret_cast< spot::atomic_prop_set * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ltl_to_tgba_fm" "', argument " "8"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg8 = reinterpret_cast< spot::tl_simplifier * >(argp8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ltl_to_tgba_fm" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(swig_obj[9], &argp10,SWIGTYPE_p_output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ltl_to_tgba_fm" "', argument " "10"" of type '" "output_aborter const *""'"); 
  }
  arg10 = reinterpret_cast< output_aborter * >(argp10);
  {
    try {
      result = spot::ltl_to_tgba_fm(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4,arg5,arg6,(std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > const *)arg7,arg8,arg9,(output_aborter const *)arg10);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_tgba_fm__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  spot::atomic_prop_set *arg7 = (spot::atomic_prop_set *) 0 ;
  spot::tl_simplifier *arg8 = (spot::tl_simplifier *) 0 ;
  bool arg9 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 9) || (nobjs > 9)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_tgba_fm" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_tgba_fm" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ltl_to_tgba_fm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ltl_to_tgba_fm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ltl_to_tgba_fm" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ltl_to_tgba_fm" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ltl_to_tgba_fm" "', argument " "7"" of type '" "spot::atomic_prop_set const *""'"); 
  }
  arg7 = reinterpret_cast< spot::atomic_prop_set * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ltl_to_tgba_fm" "', argument " "8"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg8 = reinterpret_cast< spot::tl_simplifier * >(argp8);
  ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ltl_to_tgba_fm" "', argument " "9"" of type '" "bool""'");
  } 
  arg9 = static_cast< bool >(val9);
  {
    try {
      result = spot::ltl_to_tgba_fm(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4,arg5,arg6,(std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > const *)arg7,arg8,arg9);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_tgba_fm__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  spot::atomic_prop_set *arg7 = (spot::atomic_prop_set *) 0 ;
  spot::tl_simplifier *arg8 = (spot::tl_simplifier *) 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_tgba_fm" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_tgba_fm" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ltl_to_tgba_fm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ltl_to_tgba_fm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ltl_to_tgba_fm" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ltl_to_tgba_fm" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ltl_to_tgba_fm" "', argument " "7"" of type '" "spot::atomic_prop_set const *""'"); 
  }
  arg7 = reinterpret_cast< spot::atomic_prop_set * >(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ltl_to_tgba_fm" "', argument " "8"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg8 = reinterpret_cast< spot::tl_simplifier * >(argp8);
  {
    try {
      result = spot::ltl_to_tgba_fm(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4,arg5,arg6,(std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > const *)arg7,arg8);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_tgba_fm__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  spot::atomic_prop_set *arg7 = (spot::atomic_prop_set *) 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_tgba_fm" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_tgba_fm" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ltl_to_tgba_fm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ltl_to_tgba_fm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ltl_to_tgba_fm" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ltl_to_tgba_fm" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ltl_to_tgba_fm" "', argument " "7"" of type '" "spot::atomic_prop_set const *""'"); 
  }
  arg7 = reinterpret_cast< spot::atomic_prop_set * >(argp7);
  {
    try {
      result = spot::ltl_to_tgba_fm(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4,arg5,arg6,(std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > const *)arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_tgba_fm__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_tgba_fm" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_tgba_fm" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ltl_to_tgba_fm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ltl_to_tgba_fm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ltl_to_tgba_fm" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ltl_to_tgba_fm" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = spot::ltl_to_tgba_fm(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_tgba_fm__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_tgba_fm" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_tgba_fm" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ltl_to_tgba_fm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ltl_to_tgba_fm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ltl_to_tgba_fm" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = spot::ltl_to_tgba_fm(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_tgba_fm__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_tgba_fm" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_tgba_fm" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ltl_to_tgba_fm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ltl_to_tgba_fm" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::ltl_to_tgba_fm(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_tgba_fm__SWIG_7(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_tgba_fm" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_tgba_fm" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ltl_to_tgba_fm" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::ltl_to_tgba_fm(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_tgba_fm__SWIG_8(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "ltl_to_tgba_fm" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_tgba_fm" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::ltl_to_tgba_fm(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltl_to_tgba_fm(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[11] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ltl_to_tgba_fm", 0, 10, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_ltl_to_tgba_fm__SWIG_8(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_ltl_to_tgba_fm__SWIG_7(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_ltl_to_tgba_fm__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_ltl_to_tgba_fm__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_ltl_to_tgba_fm__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_ltl_to_tgba_fm__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 8) {
    PyObject *retobj = _wrap_ltl_to_tgba_fm__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 9) {
    PyObject *retobj = _wrap_ltl_to_tgba_fm__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 10) {
    PyObject *retobj = _wrap_ltl_to_tgba_fm__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ltl_to_tgba_fm'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::ltl_to_tgba_fm(spot::formula,spot::bdd_dict_ptr const &,bool,bool,bool,bool,spot::atomic_prop_set const *,spot::tl_simplifier *,bool,output_aborter const *)\n"
    "    spot::ltl_to_tgba_fm(spot::formula,spot::bdd_dict_ptr const &,bool,bool,bool,bool,spot::atomic_prop_set const *,spot::tl_simplifier *,bool)\n"
    "    spot::ltl_to_tgba_fm(spot::formula,spot::bdd_dict_ptr const &,bool,bool,bool,bool,spot::atomic_prop_set const *,spot::tl_simplifier *)\n"
    "    spot::ltl_to_tgba_fm(spot::formula,spot::bdd_dict_ptr const &,bool,bool,bool,bool,spot::atomic_prop_set const *)\n"
    "    spot::ltl_to_tgba_fm(spot::formula,spot::bdd_dict_ptr const &,bool,bool,bool,bool)\n"
    "    spot::ltl_to_tgba_fm(spot::formula,spot::bdd_dict_ptr const &,bool,bool,bool)\n"
    "    spot::ltl_to_tgba_fm(spot::formula,spot::bdd_dict_ptr const &,bool,bool)\n"
    "    spot::ltl_to_tgba_fm(spot::formula,spot::bdd_dict_ptr const &,bool)\n"
    "    spot::ltl_to_tgba_fm(spot::formula,spot::bdd_dict_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_g_f_terminal_inplace__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "g_f_terminal_inplace" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "g_f_terminal_inplace" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::g_f_terminal_inplace(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_g_f_terminal_inplace__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "g_f_terminal_inplace" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::g_f_terminal_inplace(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_g_f_terminal_inplace(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "g_f_terminal_inplace", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_g_f_terminal_inplace__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_g_f_terminal_inplace__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'g_f_terminal_inplace'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::g_f_terminal_inplace(spot::twa_graph_ptr,bool)\n"
    "    spot::g_f_terminal_inplace(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_gf_guarantee_to_ba_maybe__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gf_guarantee_to_ba_maybe" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gf_guarantee_to_ba_maybe" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gf_guarantee_to_ba_maybe" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gf_guarantee_to_ba_maybe" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::gf_guarantee_to_ba_maybe(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gf_guarantee_to_ba_maybe__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gf_guarantee_to_ba_maybe" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gf_guarantee_to_ba_maybe" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gf_guarantee_to_ba_maybe" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::gf_guarantee_to_ba_maybe(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gf_guarantee_to_ba_maybe__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gf_guarantee_to_ba_maybe" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gf_guarantee_to_ba_maybe" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::gf_guarantee_to_ba_maybe(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gf_guarantee_to_ba_maybe(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "gf_guarantee_to_ba_maybe", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_gf_guarantee_to_ba_maybe__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_gf_guarantee_to_ba_maybe__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_gf_guarantee_to_ba_maybe__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'gf_guarantee_to_ba_maybe'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::gf_guarantee_to_ba_maybe(spot::formula,spot::bdd_dict_ptr const &,bool,bool)\n"
    "    spot::gf_guarantee_to_ba_maybe(spot::formula,spot::bdd_dict_ptr const &,bool)\n"
    "    spot::gf_guarantee_to_ba_maybe(spot::formula,spot::bdd_dict_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_gf_guarantee_to_ba__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gf_guarantee_to_ba" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gf_guarantee_to_ba" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gf_guarantee_to_ba" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gf_guarantee_to_ba" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::gf_guarantee_to_ba(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gf_guarantee_to_ba__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gf_guarantee_to_ba" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gf_guarantee_to_ba" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gf_guarantee_to_ba" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::gf_guarantee_to_ba(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gf_guarantee_to_ba__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gf_guarantee_to_ba" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gf_guarantee_to_ba" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::gf_guarantee_to_ba(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gf_guarantee_to_ba(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "gf_guarantee_to_ba", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_gf_guarantee_to_ba__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_gf_guarantee_to_ba__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_gf_guarantee_to_ba__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'gf_guarantee_to_ba'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::gf_guarantee_to_ba(spot::formula,spot::bdd_dict_ptr const &,bool,bool)\n"
    "    spot::gf_guarantee_to_ba(spot::formula,spot::bdd_dict_ptr const &,bool)\n"
    "    spot::gf_guarantee_to_ba(spot::formula,spot::bdd_dict_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fg_safety_to_dca_maybe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::twa_graph_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "fg_safety_to_dca_maybe", 3, 3, swig_obj)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fg_safety_to_dca_maybe" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fg_safety_to_dca_maybe" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fg_safety_to_dca_maybe" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::fg_safety_to_dca_maybe(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fg_safety_to_dca__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fg_safety_to_dca" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fg_safety_to_dca" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fg_safety_to_dca" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::fg_safety_to_dca(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fg_safety_to_dca__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "fg_safety_to_dca" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fg_safety_to_dca" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::fg_safety_to_dca(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fg_safety_to_dca(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fg_safety_to_dca", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_fg_safety_to_dca__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_fg_safety_to_dca__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fg_safety_to_dca'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::fg_safety_to_dca(spot::formula,spot::bdd_dict_ptr const &,bool)\n"
    "    spot::fg_safety_to_dca(spot::formula,spot::bdd_dict_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_compsusp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  bool arg8 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 8) || (nobjs > 8)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "compsusp" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "compsusp" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "compsusp" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "compsusp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "compsusp" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "compsusp" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "compsusp" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "compsusp" "', argument " "8"" of type '" "bool""'");
  } 
  arg8 = static_cast< bool >(val8);
  {
    try {
      result = spot::compsusp(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_compsusp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "compsusp" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "compsusp" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "compsusp" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "compsusp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "compsusp" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "compsusp" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "compsusp" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = spot::compsusp(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4,arg5,arg6,arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_compsusp__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "compsusp" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "compsusp" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "compsusp" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "compsusp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "compsusp" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "compsusp" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = spot::compsusp(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_compsusp__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "compsusp" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "compsusp" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "compsusp" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "compsusp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "compsusp" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = spot::compsusp(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_compsusp__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "compsusp" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "compsusp" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "compsusp" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "compsusp" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::compsusp(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_compsusp__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  bool arg3 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "compsusp" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "compsusp" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "compsusp" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::compsusp(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_compsusp__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "compsusp" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "compsusp" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::compsusp(SWIG_STD_MOVE(arg1),(std::shared_ptr< spot::bdd_dict > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_compsusp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "compsusp", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_compsusp__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_compsusp__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_compsusp__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_compsusp__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_compsusp__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_compsusp__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 8) {
    PyObject *retobj = _wrap_compsusp__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'compsusp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::compsusp(spot::formula,spot::bdd_dict_ptr const &,bool,bool,bool,bool,bool,bool)\n"
    "    spot::compsusp(spot::formula,spot::bdd_dict_ptr const &,bool,bool,bool,bool,bool)\n"
    "    spot::compsusp(spot::formula,spot::bdd_dict_ptr const &,bool,bool,bool,bool)\n"
    "    spot::compsusp(spot::formula,spot::bdd_dict_ptr const &,bool,bool,bool)\n"
    "    spot::compsusp(spot::formula,spot::bdd_dict_ptr const &,bool,bool)\n"
    "    spot::compsusp(spot::formula,spot::bdd_dict_ptr const &,bool)\n"
    "    spot::compsusp(spot::formula,spot::bdd_dict_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_contains__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::const_twa_ptr arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "contains" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "contains" "', argument " "2"" of type '" "spot::const_twa_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::contains(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_contains__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::formula arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "contains" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "contains" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (bool)spot::contains(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_contains__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::const_twa_ptr arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "contains" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "contains" "', argument " "2"" of type '" "spot::const_twa_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::contains(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_contains__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::formula arg2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "contains" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "contains" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (bool)spot::contains(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_contains(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "contains", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_contains__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      {
        _v = SWIG_CheckState(SWIG_ConvertPtr(argv[1], nullptr,
            SWIGTYPE_p_spot__formula,
            SWIG_POINTER_IMPLICIT_CONV));
      }
    }
    if (!_v) goto check_2;
    return _wrap_contains__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_contains__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_contains__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'contains'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::contains(spot::const_twa_graph_ptr,spot::const_twa_ptr)\n"
    "    spot::contains(spot::const_twa_graph_ptr,spot::formula)\n"
    "    spot::contains(spot::formula,spot::const_twa_ptr)\n"
    "    spot::contains(spot::formula,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_are_equivalent__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "are_equivalent" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "are_equivalent" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::are_equivalent(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_are_equivalent__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::formula arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "are_equivalent" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "are_equivalent" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (bool)spot::are_equivalent(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_are_equivalent__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "are_equivalent" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "are_equivalent" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::are_equivalent(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_are_equivalent__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::formula arg2 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "are_equivalent" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "are_equivalent" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (bool)spot::are_equivalent(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_are_equivalent(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "are_equivalent", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_are_equivalent__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    {
      {
        _v = SWIG_CheckState(SWIG_ConvertPtr(argv[1], nullptr,
            SWIGTYPE_p_spot__formula,
            SWIG_POINTER_IMPLICIT_CONV));
      }
    }
    if (!_v) goto check_2;
    return _wrap_are_equivalent__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_are_equivalent__SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_are_equivalent__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'are_equivalent'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::are_equivalent(spot::const_twa_graph_ptr,spot::const_twa_graph_ptr)\n"
    "    spot::are_equivalent(spot::const_twa_graph_ptr,spot::formula)\n"
    "    spot::are_equivalent(spot::formula,spot::const_twa_graph_ptr)\n"
    "    spot::are_equivalent(spot::formula,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_language_map(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "language_map" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::language_map((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_languages(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_languages" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      spot::highlight_languages(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_explicit_magic_search__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::option_map arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::emptiness_check_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "explicit_magic_search" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "explicit_magic_search" "', argument " "2"" of type '" "spot::option_map""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "explicit_magic_search" "', argument " "2"" of type '" "spot::option_map""'");
    } else {
      spot::option_map * temp = reinterpret_cast< spot::option_map * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::explicit_magic_search((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_explicit_magic_search__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  spot::emptiness_check_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "explicit_magic_search" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::explicit_magic_search((std::shared_ptr< spot::twa const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_explicit_magic_search(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "explicit_magic_search", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_explicit_magic_search__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_explicit_magic_search__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'explicit_magic_search'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::explicit_magic_search(spot::const_twa_ptr const &,spot::option_map)\n"
    "    spot::explicit_magic_search(spot::const_twa_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_bit_state_hashing_magic_search__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  size_t arg2 ;
  spot::option_map arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  spot::emptiness_check_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bit_state_hashing_magic_search" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bit_state_hashing_magic_search" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__option_map,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "bit_state_hashing_magic_search" "', argument " "3"" of type '" "spot::option_map""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "bit_state_hashing_magic_search" "', argument " "3"" of type '" "spot::option_map""'");
    } else {
      spot::option_map * temp = reinterpret_cast< spot::option_map * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = spot::bit_state_hashing_magic_search((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bit_state_hashing_magic_search__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  spot::emptiness_check_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bit_state_hashing_magic_search" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bit_state_hashing_magic_search" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      result = spot::bit_state_hashing_magic_search((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bit_state_hashing_magic_search(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "bit_state_hashing_magic_search", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_bit_state_hashing_magic_search__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_bit_state_hashing_magic_search__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'bit_state_hashing_magic_search'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::bit_state_hashing_magic_search(spot::const_twa_ptr const &,size_t,spot::option_map)\n"
    "    spot::bit_state_hashing_magic_search(spot::const_twa_ptr const &,size_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_magic_search__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  spot::option_map arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::emptiness_check_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "magic_search" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__option_map,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "magic_search" "', argument " "2"" of type '" "spot::option_map""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "magic_search" "', argument " "2"" of type '" "spot::option_map""'");
    } else {
      spot::option_map * temp = reinterpret_cast< spot::option_map * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::magic_search((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_magic_search__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  spot::emptiness_check_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "magic_search" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::magic_search((std::shared_ptr< spot::twa const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::emptiness_check > *smartresult = result ? new std::shared_ptr<  spot::emptiness_check >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__emptiness_check_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_magic_search(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "magic_search", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_magic_search__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_magic_search__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'magic_search'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::magic_search(spot::const_twa_ptr const &,spot::option_map)\n"
    "    spot::magic_search(spot::const_twa_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_minimize_monitor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_monitor" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::minimize_monitor((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_wdba__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  output_aborter *arg2 = (output_aborter *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_wdba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "minimize_wdba" "', argument " "2"" of type '" "output_aborter const *""'"); 
  }
  arg2 = reinterpret_cast< output_aborter * >(argp2);
  {
    try {
      result = spot::minimize_wdba((std::shared_ptr< spot::twa_graph const > const &)*arg1,(output_aborter const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_wdba__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_wdba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::minimize_wdba((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_wdba(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "minimize_wdba", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_minimize_wdba__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_minimize_wdba__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'minimize_wdba'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::minimize_wdba(spot::const_twa_graph_ptr const &,output_aborter const *)\n"
    "    spot::minimize_wdba(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_minimize_obligation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::formula arg2 ;
  spot::const_twa_graph_ptr arg3 ;
  bool arg4 ;
  output_aborter *arg5 = (output_aborter *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_obligation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "minimize_obligation" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "minimize_obligation" "', argument " "3"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp3) arg3 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp3));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp3);
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "minimize_obligation" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "minimize_obligation" "', argument " "5"" of type '" "output_aborter const *""'"); 
  }
  arg5 = reinterpret_cast< output_aborter * >(argp5);
  {
    try {
      result = spot::minimize_obligation((std::shared_ptr< spot::twa_graph const > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,(output_aborter const *)arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_obligation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::formula arg2 ;
  spot::const_twa_graph_ptr arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_obligation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "minimize_obligation" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "minimize_obligation" "', argument " "3"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp3) arg3 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp3));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp3);
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "minimize_obligation" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::minimize_obligation((std::shared_ptr< spot::twa_graph const > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_obligation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::formula arg2 ;
  spot::const_twa_graph_ptr arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp3 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_obligation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "minimize_obligation" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "minimize_obligation" "', argument " "3"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp3) arg3 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp3));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp3);
  }
  {
    try {
      result = spot::minimize_obligation((std::shared_ptr< spot::twa_graph const > const &)*arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_obligation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_obligation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "minimize_obligation" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = spot::minimize_obligation((std::shared_ptr< spot::twa_graph const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_obligation__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_obligation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::minimize_obligation((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_obligation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "minimize_obligation", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_minimize_obligation__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_minimize_obligation__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_minimize_obligation__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_minimize_obligation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_minimize_obligation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'minimize_obligation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::minimize_obligation(spot::const_twa_graph_ptr const &,spot::formula,spot::const_twa_graph_ptr,bool,output_aborter const *)\n"
    "    spot::minimize_obligation(spot::const_twa_graph_ptr const &,spot::formula,spot::const_twa_graph_ptr,bool)\n"
    "    spot::minimize_obligation(spot::const_twa_graph_ptr const &,spot::formula,spot::const_twa_graph_ptr)\n"
    "    spot::minimize_obligation(spot::const_twa_graph_ptr const &,spot::formula)\n"
    "    spot::minimize_obligation(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_minimize_obligation_garanteed_to_work__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::formula arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_obligation_garanteed_to_work" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "minimize_obligation_garanteed_to_work" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (bool)spot::minimize_obligation_garanteed_to_work((std::shared_ptr< spot::twa_graph const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_obligation_garanteed_to_work__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_obligation_garanteed_to_work" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::minimize_obligation_garanteed_to_work((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_obligation_garanteed_to_work(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "minimize_obligation_garanteed_to_work", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_minimize_obligation_garanteed_to_work__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_minimize_obligation_garanteed_to_work__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'minimize_obligation_garanteed_to_work'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::minimize_obligation_garanteed_to_work(spot::const_twa_graph_ptr const &,spot::formula)\n"
    "    spot::minimize_obligation_garanteed_to_work(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_mealy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_separated_mealy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_separated_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_separated_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_split_mealy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_split_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_split_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_input_deterministic_mealy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_input_deterministic_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_input_deterministic_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_split_separated_mealy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "split_separated_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::split_separated_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_split_separated_mealy_here(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "split_separated_mealy_here" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      spot::split_separated_mealy_here((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_unsplit_mealy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unsplit_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::unsplit_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_mealy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reduce_mealy" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::reduce_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_mealy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::reduce_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_mealy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "reduce_mealy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_reduce_mealy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_reduce_mealy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'reduce_mealy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::reduce_mealy(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::reduce_mealy(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_reduce_mealy_here__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_mealy_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reduce_mealy_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      spot::reduce_mealy_here(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_mealy_here__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_mealy_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      spot::reduce_mealy_here(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_mealy_here(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "reduce_mealy_here", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_reduce_mealy_here__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_reduce_mealy_here__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'reduce_mealy_here'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::reduce_mealy_here(spot::twa_graph_ptr &,bool)\n"
    "    spot::reduce_mealy_here(spot::twa_graph_ptr &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_minimize_mealy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "minimize_mealy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = spot::minimize_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_mealy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::minimize_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_mealy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::synthesis_info *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_mealy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__synthesis_info,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "minimize_mealy" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "minimize_mealy" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  arg2 = reinterpret_cast< spot::synthesis_info * >(argp2);
  {
    try {
      result = spot::minimize_mealy((std::shared_ptr< spot::twa_graph const > const &)*arg1,*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_mealy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "minimize_mealy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_minimize_mealy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__synthesis_info, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_minimize_mealy__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_minimize_mealy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'minimize_mealy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::minimize_mealy(spot::const_twa_graph_ptr const &,int)\n"
    "    spot::minimize_mealy(spot::const_twa_graph_ptr const &)\n"
    "    spot::minimize_mealy(spot::const_twa_graph_ptr const &,spot::synthesis_info &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_split_mealy_specialization__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_split_mealy_specialization" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_split_mealy_specialization" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "is_split_mealy_specialization" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (bool)spot::is_split_mealy_specialization(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_split_mealy_specialization__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_split_mealy_specialization" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_split_mealy_specialization" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::is_split_mealy_specialization(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_split_mealy_specialization(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_split_mealy_specialization", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_is_split_mealy_specialization__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_is_split_mealy_specialization__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_split_mealy_specialization'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_split_mealy_specialization(spot::const_twa_graph_ptr,spot::const_twa_graph_ptr,bool)\n"
    "    spot::is_split_mealy_specialization(spot::const_twa_graph_ptr,spot::const_twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_mealy_product(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  spot::twa_graph_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "mealy_product", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_product" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_product" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::mealy_product((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplify_mealy_here__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simplify_mealy_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simplify_mealy_here" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "simplify_mealy_here" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      spot::simplify_mealy_here(*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplify_mealy_here__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  spot::synthesis_info *arg2 = 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simplify_mealy_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__synthesis_info,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "simplify_mealy_here" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "simplify_mealy_here" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  arg2 = reinterpret_cast< spot::synthesis_info * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "simplify_mealy_here" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      spot::simplify_mealy_here(*arg1,*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simplify_mealy_here(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "simplify_mealy_here", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__synthesis_info, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_simplify_mealy_here__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_simplify_mealy_here__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'simplify_mealy_here'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::simplify_mealy_here(spot::twa_graph_ptr &,int,bool)\n"
    "    spot::simplify_mealy_here(spot::twa_graph_ptr &,spot::synthesis_info &,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_never_claim__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_never_claim" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_never_claim" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_never_claim" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_never_claim" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (std::ostream *) &spot::print_never_claim(*arg1,(std::shared_ptr< spot::twa const > const &)*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_never_claim__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_never_claim" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_never_claim" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_never_claim" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::print_never_claim(*arg1,(std::shared_ptr< spot::twa const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_never_claim(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_never_claim", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_never_claim__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_never_claim__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_never_claim'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_never_claim(std::ostream &,spot::const_twa_ptr const &,char const *)\n"
    "    spot::print_never_claim(std::ostream &,spot::const_twa_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_randomize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randomize" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "randomize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "randomize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      spot::randomize(*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randomize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randomize" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "randomize" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      spot::randomize(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randomize__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "randomize" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      spot::randomize(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_randomize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "randomize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_randomize__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_randomize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_randomize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'randomize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::randomize(spot::twa_graph_ptr &,bool,bool)\n"
    "    spot::randomize(spot::twa_graph_ptr &,bool)\n"
    "    spot::randomize(spot::twa_graph_ptr &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_rabin_is_buchi_realizable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rabin_is_buchi_realizable" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::rabin_is_buchi_realizable((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rabin_to_buchi_if_realizable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rabin_to_buchi_if_realizable" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::rabin_to_buchi_if_realizable((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rabin_to_buchi_maybe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rabin_to_buchi_maybe" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::rabin_to_buchi_maybe((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_fin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_fin" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::remove_fin((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_ap_add_ap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::remove_ap *arg1 = (spot::remove_ap *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "remove_ap_add_ap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__remove_ap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_ap_add_ap" "', argument " "1"" of type '" "spot::remove_ap *""'"); 
  }
  arg1 = reinterpret_cast< spot::remove_ap * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "remove_ap_add_ap" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      (arg1)->add_ap((char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_ap_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::remove_ap *arg1 = (spot::remove_ap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__remove_ap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_ap_empty" "', argument " "1"" of type '" "spot::remove_ap const *""'"); 
  }
  arg1 = reinterpret_cast< spot::remove_ap * >(argp1);
  {
    try {
      result = (bool)((spot::remove_ap const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_remove_ap_strip(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::remove_ap *arg1 = (spot::remove_ap *) 0 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::twa_graph_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "remove_ap_strip", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__remove_ap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "remove_ap_strip" "', argument " "1"" of type '" "spot::remove_ap const *""'"); 
  }
  arg1 = reinterpret_cast< spot::remove_ap * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "remove_ap_strip" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = ((spot::remove_ap const *)arg1)->strip(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_remove_ap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::remove_ap *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_remove_ap", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::remove_ap *)new spot::remove_ap();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__remove_ap, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_remove_ap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::remove_ap *arg1 = (spot::remove_ap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__remove_ap, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_remove_ap" "', argument " "1"" of type '" "spot::remove_ap *""'"); 
  }
  arg1 = reinterpret_cast< spot::remove_ap * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *remove_ap_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__remove_ap, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *remove_ap_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_to_finite__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_finite" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "to_finite" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::to_finite(SWIG_STD_MOVE(arg1),(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_finite__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_finite" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::to_finite(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_finite(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "to_finite", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_to_finite__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_to_finite__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'to_finite'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::to_finite(spot::const_twa_graph_ptr,char const *)\n"
    "    spot::to_finite(spot::const_twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_to_generalized_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_generalized_buchi" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::to_generalized_buchi((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streett_to_generalized_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streett_to_generalized_buchi" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::streett_to_generalized_buchi((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_streett_to_generalized_buchi_maybe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "streett_to_generalized_buchi_maybe" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::streett_to_generalized_buchi_maybe((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_generalized_rabin__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_generalized_rabin" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_generalized_rabin" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::to_generalized_rabin((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_generalized_rabin__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_generalized_rabin" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::to_generalized_rabin((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_generalized_rabin(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "to_generalized_rabin", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_to_generalized_rabin__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_to_generalized_rabin__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'to_generalized_rabin'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::to_generalized_rabin(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::to_generalized_rabin(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_to_generalized_streett__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_generalized_streett" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_generalized_streett" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::to_generalized_streett((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_generalized_streett__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_generalized_streett" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::to_generalized_streett((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_generalized_streett(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "to_generalized_streett", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_to_generalized_streett__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_to_generalized_streett__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'to_generalized_streett'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::to_generalized_streett(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::to_generalized_streett(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_dnf_to_streett__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dnf_to_streett" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dnf_to_streett" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::dnf_to_streett((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dnf_to_streett__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dnf_to_streett" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::dnf_to_streett((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dnf_to_streett(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "dnf_to_streett", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_dnf_to_streett__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_dnf_to_streett__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'dnf_to_streett'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::dnf_to_streett(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::dnf_to_streett(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_sbacc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sbacc" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::sbacc(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_keep_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::keep_all *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_keep_all", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::internal::keep_all *)new spot::internal::keep_all();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__keep_all, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_keep_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::keep_all *arg1 = (spot::internal::keep_all *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__keep_all, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_keep_all" "', argument " "1"" of type '" "spot::internal::keep_all *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::keep_all * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *keep_all_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__keep_all, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *keep_all_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_keep_inner_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg1 = 0 ;
  unsigned int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::internal::keep_inner_scc *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_keep_inner_scc", 2, 2, swig_obj)) 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_keep_inner_scc" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_keep_inner_scc" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_keep_inner_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::internal::keep_inner_scc *)new spot::internal::keep_inner_scc((std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__keep_inner_scc, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_keep_inner_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::keep_inner_scc *arg1 = (spot::internal::keep_inner_scc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__keep_inner_scc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_keep_inner_scc" "', argument " "1"" of type '" "spot::internal::keep_inner_scc *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::keep_inner_scc * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *keep_inner_scc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__keep_inner_scc, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *keep_inner_scc_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_scc_info_node__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::scc_info_node *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::scc_info_node *)new spot::scc_info_node();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_info_node, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_info_node__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond::mark_t arg1 ;
  spot::acc_cond::mark_t arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::scc_info_node *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info_node" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_info_node" "', argument " "1"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_scc_info_node" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_info_node" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_scc_info_node" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (spot::scc_info_node *)new spot::scc_info_node(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_info_node, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_info_node(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_scc_info_node", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_scc_info_node__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_scc_info_node__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_scc_info_node'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::scc_info_node::scc_info_node()\n"
    "    spot::scc_info_node::scc_info_node(spot::acc_cond::mark_t,spot::acc_cond::mark_t,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_scc_info_node_is_trivial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_node *arg1 = (spot::scc_info_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info_node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_node_is_trivial" "', argument " "1"" of type '" "spot::scc_info_node const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info_node * >(argp1);
  {
    try {
      result = (bool)((spot::scc_info_node const *)arg1)->is_trivial();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_node_is_accepting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_node *arg1 = (spot::scc_info_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info_node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_node_is_accepting" "', argument " "1"" of type '" "spot::scc_info_node const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info_node * >(argp1);
  {
    try {
      result = (bool)((spot::scc_info_node const *)arg1)->is_accepting();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_node_is_rejecting(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_node *arg1 = (spot::scc_info_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info_node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_node_is_rejecting" "', argument " "1"" of type '" "spot::scc_info_node const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info_node * >(argp1);
  {
    try {
      result = (bool)((spot::scc_info_node const *)arg1)->is_rejecting();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_node_is_useful(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_node *arg1 = (spot::scc_info_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info_node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_node_is_useful" "', argument " "1"" of type '" "spot::scc_info_node const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info_node * >(argp1);
  {
    try {
      result = (bool)((spot::scc_info_node const *)arg1)->is_useful();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_node_acc_marks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_node *arg1 = (spot::scc_info_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info_node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_node_acc_marks" "', argument " "1"" of type '" "spot::scc_info_node const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info_node * >(argp1);
  {
    try {
      result = ((spot::scc_info_node const *)arg1)->acc_marks();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_node_common_marks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_node *arg1 = (spot::scc_info_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::acc_cond::mark_t result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info_node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_node_common_marks" "', argument " "1"" of type '" "spot::scc_info_node const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info_node * >(argp1);
  {
    try {
      result = ((spot::scc_info_node const *)arg1)->common_marks();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_node_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_node *arg1 = (spot::scc_info_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info_node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_node_states" "', argument " "1"" of type '" "spot::scc_info_node const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info_node * >(argp1);
  {
    try {
      result = (std::vector< unsigned int,std::allocator< unsigned int > > *) &((spot::scc_info_node const *)arg1)->states();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_node_one_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_node *arg1 = (spot::scc_info_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info_node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_node_one_state" "', argument " "1"" of type '" "spot::scc_info_node const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info_node * >(argp1);
  {
    try {
      result = (unsigned int)((spot::scc_info_node const *)arg1)->one_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_node_succ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_node *arg1 = (spot::scc_info_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::scc_info_node::scc_succs *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info_node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_node_succ" "', argument " "1"" of type '" "spot::scc_info_node const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info_node * >(argp1);
  {
    try {
      result = (spot::scc_info_node::scc_succs *) &((spot::scc_info_node const *)arg1)->succ();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_scc_info_node(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_node *arg1 = (spot::scc_info_node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info_node, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scc_info_node" "', argument " "1"" of type '" "spot::scc_info_node *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info_node * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *scc_info_node_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__scc_info_node, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *scc_info_node_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___and__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_options arg1 ;
  spot::scc_info_options arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::scc_info_options result;
  
  if (!SWIG_Python_UnpackTuple(args, "__and__", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__and__" "', argument " "1"" of type '" "spot::scc_info_options""'");
  } 
  arg1 = static_cast< spot::scc_info_options >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "__and__" "', argument " "2"" of type '" "spot::scc_info_options""'");
  } 
  arg2 = static_cast< spot::scc_info_options >(val2);
  {
    try {
      result = (spot::scc_info_options)spot::operator &(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___or__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info_options arg1 ;
  spot::scc_info_options arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::scc_info_options result;
  
  if (!SWIG_Python_UnpackTuple(args, "__or__", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__or__" "', argument " "1"" of type '" "spot::scc_info_options""'");
  } 
  arg1 = static_cast< spot::scc_info_options >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "__or__" "', argument " "2"" of type '" "spot::scc_info_options""'");
  } 
  arg2 = static_cast< spot::scc_info_options >(val2);
  {
    try {
      result = (spot::scc_info_options)spot::operator |(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_new_scc_info__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  unsigned int arg2 ;
  spot::scc_info::edge_filter arg3 = (spot::scc_info::edge_filter) 0 ;
  void *arg4 = (void *) 0 ;
  spot::scc_info_options arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res4 ;
  int val5 ;
  int ecode5 = 0 ;
  spot::scc_info *result = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_scc_info" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_scc_info" "', argument " "3"" of type '" "spot::scc_info::edge_filter""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_scc_info" "', argument " "4"" of type '" "void *""'"); 
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_scc_info" "', argument " "5"" of type '" "spot::scc_info_options""'");
  } 
  arg5 = static_cast< spot::scc_info_options >(val5);
  {
    try {
      result = (spot::scc_info *)new spot::scc_info(arg1,arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_info__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  unsigned int arg2 ;
  spot::scc_info::edge_filter arg3 = (spot::scc_info::edge_filter) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res4 ;
  spot::scc_info *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_scc_info" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_scc_info" "', argument " "3"" of type '" "spot::scc_info::edge_filter""'"); 
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_scc_info" "', argument " "4"" of type '" "void *""'"); 
  }
  {
    try {
      result = (spot::scc_info *)new spot::scc_info(arg1,arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_info__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  unsigned int arg2 ;
  spot::scc_info::edge_filter arg3 = (spot::scc_info::edge_filter) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::scc_info *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_scc_info" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[2], (void**)(&arg3), SWIGTYPE_p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_scc_info" "', argument " "3"" of type '" "spot::scc_info::edge_filter""'"); 
    }
  }
  {
    try {
      result = (spot::scc_info *)new spot::scc_info(arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_info__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::scc_info *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_scc_info" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::scc_info *)new spot::scc_info(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_info__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::scc_info *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = (spot::scc_info *)new spot::scc_info(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_info_with_options__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::scc_info_options arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::scc_info *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info_with_options" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_scc_info_with_options" "', argument " "2"" of type '" "spot::scc_info_options""'");
  } 
  arg2 = static_cast< spot::scc_info_options >(val2);
  {
    try {
      result = (spot::scc_info *)new spot::scc_info(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_info, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_info_with_options__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_and_mark_filter *arg1 = 0 ;
  spot::scc_info_options arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::scc_info *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_and_mark_filter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info_with_options" "', argument " "1"" of type '" "spot::scc_and_mark_filter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_info_with_options" "', argument " "1"" of type '" "spot::scc_and_mark_filter const &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_and_mark_filter * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_scc_info_with_options" "', argument " "2"" of type '" "spot::scc_info_options""'");
  } 
  arg2 = static_cast< spot::scc_info_options >(val2);
  {
    try {
      result = (spot::scc_info *)new spot::scc_info((spot::scc_and_mark_filter const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_info, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_info_with_options(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_scc_info_with_options", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_new_scc_info_with_options__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_scc_info_with_options__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_scc_info_with_options'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::scc_info::scc_info(spot::const_twa_graph_ptr,spot::scc_info_options)\n"
    "    spot::scc_info::scc_info(spot::scc_and_mark_filter const &,spot::scc_info_options)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_scc_info__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_and_mark_filter *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::scc_info *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_and_mark_filter,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info" "', argument " "1"" of type '" "spot::scc_and_mark_filter const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_info" "', argument " "1"" of type '" "spot::scc_and_mark_filter const &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_and_mark_filter * >(argp1);
  {
    try {
      result = (spot::scc_info *)new spot::scc_info((spot::scc_and_mark_filter const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_info(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_scc_info", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_scc_info__SWIG_4(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_scc_info__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_scc_info__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_scc_info__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_scc_info__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_new_scc_info__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_scc_info'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::scc_info::scc_info(spot::const_twa_graph_ptr,unsigned int,spot::scc_info::edge_filter,void *,spot::scc_info_options)\n"
    "    spot::scc_info::scc_info(spot::const_twa_graph_ptr,unsigned int,spot::scc_info::edge_filter,void *)\n"
    "    spot::scc_info::scc_info(spot::const_twa_graph_ptr,unsigned int,spot::scc_info::edge_filter)\n"
    "    spot::scc_info::scc_info(spot::const_twa_graph_ptr,unsigned int)\n"
    "    spot::scc_info::scc_info(spot::const_twa_graph_ptr)\n"
    "    spot::scc_info::scc_info(spot::scc_and_mark_filter const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_scc_info_get_aut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::const_twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_get_aut" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = ((spot::scc_info const *)arg1)->get_aut();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr< const spot::twa_graph > *smartresult = result ? new std::shared_ptr< const spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_get_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::scc_info_options result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_get_options" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = (spot::scc_info_options)((spot::scc_info const *)arg1)->get_options();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_get_filter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::scc_info::edge_filter result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_get_filter" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = (spot::scc_info::edge_filter)((spot::scc_info const *)arg1)->get_filter();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_get_filter_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  void *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_get_filter_data" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = (void *)((spot::scc_info const *)arg1)->get_filter_data();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_scc_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_scc_count" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = (unsigned int)((spot::scc_info const *)arg1)->scc_count();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_one_accepting_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_one_accepting_scc" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = (int)((spot::scc_info const *)arg1)->one_accepting_scc();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_reachable_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_reachable_state", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_reachable_state" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_reachable_state" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::scc_info const *)arg1)->reachable_state(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_scc_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_scc_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_scc_of" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_scc_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)((spot::scc_info const *)arg1)->scc_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< spot::scc_info_node,std::allocator< spot::scc_info_node > >::const_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_begin" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = ((spot::scc_info const *)arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::scc_info::scc_node,std::allocator< spot::scc_info::scc_node > >::const_iterator(result)), SWIGTYPE_p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< spot::scc_info_node,std::allocator< spot::scc_info_node > >::const_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_end" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = ((spot::scc_info const *)arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::scc_info::scc_node,std::allocator< spot::scc_info::scc_node > >::const_iterator(result)), SWIGTYPE_p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_cbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< spot::scc_info_node,std::allocator< spot::scc_info_node > >::const_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_cbegin" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = ((spot::scc_info const *)arg1)->cbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::scc_info::scc_node,std::allocator< spot::scc_info::scc_node > >::const_iterator(result)), SWIGTYPE_p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_cend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< spot::scc_info_node,std::allocator< spot::scc_info_node > >::const_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_cend" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = ((spot::scc_info const *)arg1)->cend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::scc_info::scc_node,std::allocator< spot::scc_info::scc_node > >::const_iterator(result)), SWIGTYPE_p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< spot::scc_info_node,std::allocator< spot::scc_info_node > >::const_reverse_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_rbegin" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = ((spot::scc_info const *)arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::scc_info::scc_node,std::allocator< spot::scc_info::scc_node > >::const_reverse_iterator(result)), SWIGTYPE_p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_reverse_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< spot::scc_info_node,std::allocator< spot::scc_info_node > >::const_reverse_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_rend" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = ((spot::scc_info const *)arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::scc_info::scc_node,std::allocator< spot::scc_info::scc_node > >::const_reverse_iterator(result)), SWIGTYPE_p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_reverse_iterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_states_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_states_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_states_of" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_states_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (std::vector< unsigned int,std::allocator< unsigned int > > *) &((spot::scc_info const *)arg1)->states_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_edges_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_edges_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_edges_of" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_edges_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    resultobj = SWIG_NewPointerObj((new spot::internal::scc_edges< spot::twa_graph::graph_t const,spot::internal::keep_all >(((spot::scc_info const *)arg1)->edges_of(arg2))), SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_inner_edges_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_inner_edges_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_inner_edges_of" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_inner_edges_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    resultobj = SWIG_NewPointerObj((new spot::internal::scc_edges< spot::twa_graph::graph_t const,spot::internal::keep_inner_scc >(((spot::scc_info const *)arg1)->inner_edges_of(arg2))), SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_one_state_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_one_state_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_one_state_of" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_one_state_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)((spot::scc_info const *)arg1)->one_state_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_initial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_initial" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = (unsigned int)((spot::scc_info const *)arg1)->initial();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_succ(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::scc_info::scc_succs *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_succ", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_succ" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_succ" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::scc_info::scc_succs *) &((spot::scc_info const *)arg1)->succ(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_is_trivial(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_is_trivial", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_is_trivial" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_is_trivial" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::scc_info const *)arg1)->is_trivial(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_acc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_acc", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_acc" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_acc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::scc_info const *)arg1)->acc(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_is_accepting_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_is_accepting_scc", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_is_accepting_scc" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_is_accepting_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::scc_info const *)arg1)->is_accepting_scc(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_is_rejecting_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_is_rejecting_scc", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_is_rejecting_scc" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_is_rejecting_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::scc_info const *)arg1)->is_rejecting_scc(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_is_maximally_accepting_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_is_maximally_accepting_scc", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_is_maximally_accepting_scc" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_is_maximally_accepting_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::scc_info const *)arg1)->is_maximally_accepting_scc(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_determine_unknown_acceptance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_determine_unknown_acceptance" "', argument " "1"" of type '" "spot::scc_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      (arg1)->determine_unknown_acceptance();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_check_scc_emptiness(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_check_scc_emptiness", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_check_scc_emptiness" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_check_scc_emptiness" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::scc_info const *)arg1)->check_scc_emptiness(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_get_accepting_run(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  spot::twa_run_ptr arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_get_accepting_run", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_get_accepting_run" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_get_accepting_run" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "scc_info_get_accepting_run" "', argument " "3"" of type '" "spot::twa_run_ptr""'");
    }
    if (argp3) arg3 = *(reinterpret_cast< spot::twa_run_ptr * >(argp3));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_run_ptr * >(argp3);
  }
  {
    try {
      ((spot::scc_info const *)arg1)->get_accepting_run(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_is_useful_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_is_useful_scc", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_is_useful_scc" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_is_useful_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::scc_info const *)arg1)->is_useful_scc(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_is_useful_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_is_useful_state", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_is_useful_state" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_is_useful_state" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::scc_info const *)arg1)->is_useful_state(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_marks(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > >,std::allocator< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_marks" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = ((spot::scc_info const *)arg1)->marks();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > >,std::allocator< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > > > >(result)), SWIGTYPE_p_std__vectorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_std__allocatorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_marks_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_marks_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_marks_of" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_marks_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::scc_info const *)arg1)->marks_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > >(result)), SWIGTYPE_p_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_used_acc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > >,std::allocator< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_used_acc" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = ((spot::scc_info const *)arg1)->used_acc();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > >,std::allocator< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > > > >(result)), SWIGTYPE_p_std__vectorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_std__allocatorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_used_acc_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_used_acc_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_used_acc_of" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_used_acc_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::scc_info const *)arg1)->used_acc_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > >(result)), SWIGTYPE_p_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_acc_sets_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_acc_sets_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_acc_sets_of" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_acc_sets_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::scc_info const *)arg1)->acc_sets_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_common_sets_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_common_sets_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_common_sets_of" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_common_sets_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::scc_info const *)arg1)->common_sets_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_weak_sccs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool,std::allocator< bool > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_weak_sccs" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = ((spot::scc_info const *)arg1)->weak_sccs();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_scc_ap_support(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bdd result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_scc_ap_support", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_scc_ap_support" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_scc_ap_support" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::scc_info const *)arg1)->scc_ap_support(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_split_on_sets__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  spot::acc_cond::mark_t arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  std::vector< spot::twa_graph_ptr,std::allocator< spot::twa_graph_ptr > > result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_split_on_sets" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_split_on_sets" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "scc_info_split_on_sets" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "scc_info_split_on_sets" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "scc_info_split_on_sets" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = ((spot::scc_info const *)arg1)->split_on_sets(arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::twa_graph_ptr,std::allocator< spot::twa_graph_ptr > >(result)), SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_split_on_sets__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  spot::acc_cond::mark_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< spot::twa_graph_ptr,std::allocator< spot::twa_graph_ptr > > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_split_on_sets" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_split_on_sets" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "scc_info_split_on_sets" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "scc_info_split_on_sets" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = ((spot::scc_info const *)arg1)->split_on_sets(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::twa_graph_ptr,std::allocator< spot::twa_graph_ptr > >(result)), SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_split_on_sets(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "scc_info_split_on_sets", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_scc_info_split_on_sets__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_scc_info_split_on_sets__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'scc_info_split_on_sets'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::scc_info::split_on_sets(unsigned int,spot::acc_cond::mark_t,bool) const\n"
    "    spot::scc_info::split_on_sets(unsigned int,spot::acc_cond::mark_t) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_scc_info_states_on_acc_cycle_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_info_states_on_acc_cycle_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_states_on_acc_cycle_of" "', argument " "1"" of type '" "spot::scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_info_states_on_acc_cycle_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::scc_info const *)arg1)->states_on_acc_cycle_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info___iter__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info___iter__" "', argument " "1"" of type '" "spot::scc_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)spot_scc_info___iter__(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_scc_info(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scc_info" "', argument " "1"" of type '" "spot::scc_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *scc_info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__scc_info, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *scc_info_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_scc_and_mark_filter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::mark_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  spot::scc_and_mark_filter *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_and_mark_filter" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_and_mark_filter" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_scc_and_mark_filter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_scc_and_mark_filter" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_and_mark_filter" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (spot::scc_and_mark_filter *)new spot::scc_and_mark_filter((spot::scc_info const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_and_mark_filter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_and_mark_filter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::mark_t arg3 ;
  bitvect *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  spot::scc_and_mark_filter *result = 0 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_and_mark_filter" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_and_mark_filter" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_scc_and_mark_filter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_scc_and_mark_filter" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_and_mark_filter" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bitvect,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_scc_and_mark_filter" "', argument " "4"" of type '" "bitvect const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_and_mark_filter" "', argument " "4"" of type '" "bitvect const &""'"); 
  }
  arg4 = reinterpret_cast< bitvect * >(argp4);
  {
    try {
      result = (spot::scc_and_mark_filter *)new spot::scc_and_mark_filter((spot::scc_info const &)*arg1,arg2,arg3,(bitvect const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_and_mark_filter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_and_mark_filter__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::acc_cond::mark_t arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::scc_and_mark_filter *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_and_mark_filter" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_scc_and_mark_filter" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_and_mark_filter" "', argument " "2"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::scc_and_mark_filter *)new spot::scc_and_mark_filter((spot::const_twa_graph_ptr const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__scc_and_mark_filter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_scc_and_mark_filter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_scc_and_mark_filter", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_new_scc_and_mark_filter__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_scc_and_mark_filter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_new_scc_and_mark_filter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_scc_and_mark_filter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::scc_and_mark_filter::scc_and_mark_filter(spot::scc_info const &,unsigned int,spot::acc_cond::mark_t)\n"
    "    spot::scc_and_mark_filter::scc_and_mark_filter(spot::scc_info const &,unsigned int,spot::acc_cond::mark_t,bitvect const &)\n"
    "    spot::scc_and_mark_filter::scc_and_mark_filter(spot::const_twa_graph_ptr const &,spot::acc_cond::mark_t)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_scc_and_mark_filter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_and_mark_filter *arg1 = (spot::scc_and_mark_filter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_and_mark_filter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scc_and_mark_filter" "', argument " "1"" of type '" "spot::scc_and_mark_filter *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_and_mark_filter * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_and_mark_filter_override_acceptance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_and_mark_filter *arg1 = (spot::scc_and_mark_filter *) 0 ;
  spot::acc_cond *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_and_mark_filter_override_acceptance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_and_mark_filter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_and_mark_filter_override_acceptance" "', argument " "1"" of type '" "spot::scc_and_mark_filter *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_and_mark_filter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scc_and_mark_filter_override_acceptance" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "scc_and_mark_filter_override_acceptance" "', argument " "2"" of type '" "spot::acc_cond const &""'"); 
  }
  arg2 = reinterpret_cast< spot::acc_cond * >(argp2);
  {
    try {
      (arg1)->override_acceptance((spot::acc_cond const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_and_mark_filter_restore_acceptance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_and_mark_filter *arg1 = (spot::scc_and_mark_filter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_and_mark_filter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_and_mark_filter_restore_acceptance" "', argument " "1"" of type '" "spot::scc_and_mark_filter *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_and_mark_filter * >(argp1);
  {
    try {
      (arg1)->restore_acceptance();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_and_mark_filter_get_aut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_and_mark_filter *arg1 = (spot::scc_and_mark_filter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::const_twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_and_mark_filter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_and_mark_filter_get_aut" "', argument " "1"" of type '" "spot::scc_and_mark_filter const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_and_mark_filter * >(argp1);
  {
    try {
      result = ((spot::scc_and_mark_filter const *)arg1)->get_aut();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr< const spot::twa_graph > *smartresult = result ? new std::shared_ptr< const spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_and_mark_filter_start_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_and_mark_filter *arg1 = (spot::scc_and_mark_filter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_and_mark_filter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_and_mark_filter_start_state" "', argument " "1"" of type '" "spot::scc_and_mark_filter const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_and_mark_filter * >(argp1);
  {
    try {
      result = (unsigned int)((spot::scc_and_mark_filter const *)arg1)->start_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_and_mark_filter_get_filter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_and_mark_filter *arg1 = (spot::scc_and_mark_filter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::scc_info::edge_filter result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__scc_and_mark_filter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_and_mark_filter_get_filter" "', argument " "1"" of type '" "spot::scc_and_mark_filter const *""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_and_mark_filter * >(argp1);
  {
    try {
      result = (spot::scc_info::edge_filter)((spot::scc_and_mark_filter const *)arg1)->get_filter();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *scc_and_mark_filter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__scc_and_mark_filter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *scc_and_mark_filter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_dump_scc_info_dot__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_graph_ptr arg2 ;
  spot::scc_info *arg3 = (spot::scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dump_scc_info_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dump_scc_info_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dump_scc_info_dot" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dump_scc_info_dot" "', argument " "3"" of type '" "spot::scc_info *""'"); 
  }
  arg3 = reinterpret_cast< spot::scc_info * >(argp3);
  {
    try {
      result = (std::ostream *) &spot::dump_scc_info_dot(*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dump_scc_info_dot__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dump_scc_info_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dump_scc_info_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dump_scc_info_dot" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (std::ostream *) &spot::dump_scc_info_dot(*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dump_scc_info_dot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "dump_scc_info_dot", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_dump_scc_info_dot__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_dump_scc_info_dot__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'dump_scc_info_dot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::dump_scc_info_dot(std::ostream &,spot::const_twa_graph_ptr,spot::scc_info *)\n"
    "    spot::dump_scc_info_dot(std::ostream &,spot::const_twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_scc_info_scc_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator > arg1 ;
  SwigValueWrapper< spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator > arg2 ;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::tv_t *arg3 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::tv_t *) 0 ;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::sv_t *arg4 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::sv_t *) 0 ;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::dv_t *arg5 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::dv_t *) 0 ;
  spot::internal::keep_all arg6 ;
  spot::edge_filter arg7 = (spot::edge_filter) 0 ;
  void *arg8 = (void *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  int res8 ;
  PyObject *swig_obj[8] ;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_scc_info_scc_edges", 8, 8, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__state_iterator,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info_scc_edges" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_info_scc_edges" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator""'");
    } else {
      spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator * temp = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__state_iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_scc_info_scc_edges" "', argument " "2"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_info_scc_edges" "', argument " "2"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator""'");
    } else {
      spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator * temp = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__tv_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_scc_info_scc_edges" "', argument " "3"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::tv_t *""'"); 
  }
  arg3 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::tv_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__sv_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_scc_info_scc_edges" "', argument " "4"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::sv_t *""'"); 
  }
  arg4 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::sv_t * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__dv_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_scc_info_scc_edges" "', argument " "5"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::dv_t *""'"); 
  }
  arg5 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::dv_t * >(argp5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_spot__internal__keep_all,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_scc_info_scc_edges" "', argument " "6"" of type '" "spot::internal::keep_all""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_info_scc_edges" "', argument " "6"" of type '" "spot::internal::keep_all""'");
    } else {
      spot::internal::keep_all * temp = reinterpret_cast< spot::internal::keep_all * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[6], (void**)(&arg7), SWIGTYPE_p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_scc_info_scc_edges" "', argument " "7"" of type '" "spot::edge_filter""'"); 
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7],SWIG_as_voidptrptr(&arg8), 0, 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_scc_info_scc_edges" "', argument " "8"" of type '" "void *""'"); 
  }
  {
    try {
      result = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *)new spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_scc_edges_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *arg1 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_scc_edges_begin" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > * >(argp1);
  {
    try {
      result = ((spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > const *)arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::iter_t(result)), SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_scc_edges_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *arg1 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_scc_edges_end" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > * >(argp1);
  {
    try {
      result = ((spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > const *)arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::iter_t(result)), SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_scc_edges___iter__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *arg1 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_scc_edges___iter__" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)spot_internal_scc_edges_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg_const_Sc_spot_internal_keep_all_Sg____iter__(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_scc_info_scc_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *arg1 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scc_info_scc_edges" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *scc_info_scc_edges_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *scc_info_scc_edges_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_scc_info_inner_scc_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SwigValueWrapper< spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator > arg1 ;
  SwigValueWrapper< spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator > arg2 ;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::tv_t *arg3 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::tv_t *) 0 ;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::sv_t *arg4 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::sv_t *) 0 ;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::dv_t *arg5 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::dv_t *) 0 ;
  SwigValueWrapper< spot::internal::keep_inner_scc > arg6 ;
  spot::edge_filter arg7 = (spot::edge_filter) 0 ;
  void *arg8 = (void *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  int res8 ;
  PyObject *swig_obj[8] ;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_scc_info_inner_scc_edges", 8, 8, swig_obj)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__state_iterator,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_scc_info_inner_scc_edges" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_info_inner_scc_edges" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator""'");
    } else {
      spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator * temp = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__state_iterator,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_scc_info_inner_scc_edges" "', argument " "2"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_info_inner_scc_edges" "', argument " "2"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator""'");
    } else {
      spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator * temp = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__tv_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_scc_info_inner_scc_edges" "', argument " "3"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::tv_t *""'"); 
  }
  arg3 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::tv_t * >(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__sv_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_scc_info_inner_scc_edges" "', argument " "4"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::sv_t *""'"); 
  }
  arg4 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::sv_t * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__dv_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_scc_info_inner_scc_edges" "', argument " "5"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::dv_t *""'"); 
  }
  arg5 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::dv_t * >(argp5);
  {
    res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_spot__internal__keep_inner_scc,  0  | 0);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_scc_info_inner_scc_edges" "', argument " "6"" of type '" "spot::internal::keep_inner_scc""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_scc_info_inner_scc_edges" "', argument " "6"" of type '" "spot::internal::keep_inner_scc""'");
    } else {
      spot::internal::keep_inner_scc * temp = reinterpret_cast< spot::internal::keep_inner_scc * >(argp6);
      arg6 = *temp;
      if (SWIG_IsNewObj(res6)) delete temp;
    }
  }
  {
    int res = SWIG_ConvertFunctionPtr(swig_obj[6], (void**)(&arg7), SWIGTYPE_p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_scc_info_inner_scc_edges" "', argument " "7"" of type '" "spot::edge_filter""'"); 
    }
  }
  res8 = SWIG_ConvertPtr(swig_obj[7],SWIG_as_voidptrptr(&arg8), 0, 0);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_scc_info_inner_scc_edges" "', argument " "8"" of type '" "void *""'"); 
  }
  {
    try {
      result = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *)new spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_inner_scc_edges_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *arg1 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_inner_scc_edges_begin" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > * >(argp1);
  {
    try {
      result = ((spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > const *)arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::iter_t(result)), SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_inner_scc_edges_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *arg1 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_inner_scc_edges_end" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > * >(argp1);
  {
    try {
      result = ((spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > const *)arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::iter_t(result)), SWIGTYPE_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_info_inner_scc_edges___iter__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *arg1 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_info_inner_scc_edges___iter__" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)spot_internal_scc_edges_Sl_spot_digraph_Sl_spot_twa_graph_state_Sc_spot_twa_graph_edge_data_Sg_const_Sc_spot_internal_keep_inner_scc_Sg____iter__(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_scc_info_inner_scc_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *arg1 = (spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scc_info_inner_scc_edges" "', argument " "1"" of type '" "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *scc_info_inner_scc_edges_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *scc_info_inner_scc_edges_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_vector_twa_graph_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_iterator" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_spot_twa_graph_ptr_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___nonzero__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_twa_graph_ptr_Sg____nonzero__((std::vector< std::shared_ptr< spot::twa_graph > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___bool__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_twa_graph_ptr_Sg____bool__((std::vector< std::shared_ptr< spot::twa_graph > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::shared_ptr< spot::twa_graph > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___len__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = std_vector_Sl_spot_twa_graph_ptr_Sg____len__((std::vector< std::shared_ptr< spot::twa_graph > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg2 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_twa_graph___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___getslice__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph___getslice__" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_twa_graph___getslice__" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *)std_vector_Sl_spot_twa_graph_ptr_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg2 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___setslice__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph___setslice__" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_twa_graph___setslice__" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_twa_graph_ptr_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg2 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg3 ;
  std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___setslice__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph___setslice__" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_twa_graph___setslice__" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val3);
  {
    std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *ptr = (std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_twa_graph___setslice__" "', argument " "4"" of type '" "std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_twa_graph___setslice__" "', argument " "4"" of type '" "std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_twa_graph_ptr_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_twa_graph___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vector_twa_graph___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vector_twa_graph___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_twa_graph___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::twa_graph_ptr >::__setslice__(std::vector< std::shared_ptr< spot::twa_graph > >::difference_type,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type)\n"
    "    std::vector< spot::twa_graph_ptr >::__setslice__(std::vector< std::shared_ptr< spot::twa_graph > >::difference_type,std::vector< std::shared_ptr< spot::twa_graph > >::difference_type,std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg2 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_twa_graph___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___delslice__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph___delslice__" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_twa_graph___delslice__" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_twa_graph_ptr_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___delitem__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph___delitem__" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_spot_twa_graph_ptr_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___getitem__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_twa_graph___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *)std_vector_Sl_spot_twa_graph_ptr_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___setitem__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_twa_graph___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *ptr = (std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_twa_graph___setitem__" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_twa_graph___setitem__" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_twa_graph_ptr_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___setitem__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_twa_graph___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_twa_graph_ptr_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___delitem__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_twa_graph___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_twa_graph_ptr_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_twa_graph___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vector_twa_graph___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vector_twa_graph___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_twa_graph___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::twa_graph_ptr >::__delitem__(std::vector< std::shared_ptr< spot::twa_graph > >::difference_type)\n"
    "    std::vector< spot::twa_graph_ptr >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___getitem__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph___getitem__" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::shared_ptr< spot::twa_graph > >::value_type *) &std_vector_Sl_spot_twa_graph_ptr_Sg____getitem____SWIG_1((std::vector< std::shared_ptr< spot::twa_graph > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = *result ? new std::shared_ptr<  spot::twa_graph >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< std::shared_ptr< spot::twa_graph > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_twa_graph___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_vector_twa_graph___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_vector_twa_graph___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_twa_graph___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::twa_graph_ptr >::__getitem__(PySliceObject *)\n"
    "    std::vector< spot::twa_graph_ptr >::__getitem__(std::vector< std::shared_ptr< spot::twa_graph > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::difference_type arg2 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph___setitem__" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph___setitem__" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::difference_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_twa_graph___setitem__" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      try {
        std_vector_Sl_spot_twa_graph_ptr_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< spot::twa_graph > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_twa_graph___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vector_twa_graph___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_vector_twa_graph___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_vector_twa_graph___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_twa_graph___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::twa_graph_ptr >::__setitem__(PySliceObject *,std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > const &)\n"
    "    std::vector< spot::twa_graph_ptr >::__setitem__(PySliceObject *)\n"
    "    std::vector< spot::twa_graph_ptr >::__setitem__(std::vector< std::shared_ptr< spot::twa_graph > >::difference_type,std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_pop" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_spot_twa_graph_ptr_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_twa_graph_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_append" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vector_twa_graph_append" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      std_vector_Sl_spot_twa_graph_ptr_Sg__append(arg1,(std::shared_ptr< spot::twa_graph > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vector_twa_graph__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< spot::twa_graph_ptr > *)new std::vector< spot::twa_graph_ptr >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vector_twa_graph__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< spot::twa_graph_ptr > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *ptr = (std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_twa_graph" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vector_twa_graph" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< spot::twa_graph_ptr > *)new std::vector< spot::twa_graph_ptr >((std::vector< spot::twa_graph_ptr > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_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_vector_twa_graph_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_empty" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = (bool)((std::vector< spot::twa_graph_ptr > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::shared_ptr< spot::twa_graph > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_size" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = ((std::vector< spot::twa_graph_ptr > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< spot::twa_graph_ptr > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_twa_graph_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_swap" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vector_twa_graph_swap" "', argument " "2"" of type '" "std::vector< spot::twa_graph_ptr > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_twa_graph_swap" "', argument " "2"" of type '" "std::vector< spot::twa_graph_ptr > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_begin" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::shared_ptr< spot::twa_graph > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_end" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::shared_ptr< spot::twa_graph > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::reverse_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_rbegin" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::shared_ptr< spot::twa_graph > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::reverse_iterator > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_rend" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::shared_ptr< spot::twa_graph > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_clear" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::shared_ptr< spot::twa_graph > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_get_allocator" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = ((std::vector< spot::twa_graph_ptr > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::shared_ptr< spot::twa_graph > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vector_twa_graph__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::shared_ptr< spot::twa_graph > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< spot::twa_graph_ptr > *result = 0 ;
  
  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_vector_twa_graph" "', argument " "1"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::size_type >(val1);
  {
    try {
      result = (std::vector< spot::twa_graph_ptr > *)new std::vector< spot::twa_graph_ptr >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_pop_back" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_resize" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph_resize" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::iterator > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::iterator > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_erase" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(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 '" "vector_twa_graph_erase" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::shared_ptr< spot::twa_graph > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::shared_ptr< spot::twa_graph > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_twa_graph_erase" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_twa_graph_ptr_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::shared_ptr< spot::twa_graph > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::iterator > arg2 ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::iterator > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::iterator > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_erase" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(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 '" "vector_twa_graph_erase" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::shared_ptr< spot::twa_graph > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::shared_ptr< spot::twa_graph > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_twa_graph_erase" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::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 '" "vector_twa_graph_erase" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::shared_ptr< spot::twa_graph > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::shared_ptr< spot::twa_graph > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_twa_graph_erase" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_twa_graph_ptr_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::shared_ptr< spot::twa_graph > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_twa_graph_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vector_twa_graph_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vector_twa_graph_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_twa_graph_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::twa_graph_ptr >::erase(std::vector< std::shared_ptr< spot::twa_graph > >::iterator)\n"
    "    std::vector< spot::twa_graph_ptr >::erase(std::vector< std::shared_ptr< spot::twa_graph > >::iterator,std::vector< std::shared_ptr< spot::twa_graph > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_vector_twa_graph__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::shared_ptr< spot::twa_graph > >::size_type arg1 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type tempshared2 ;
  std::vector< spot::twa_graph_ptr > *result = 0 ;
  
  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_vector_twa_graph" "', argument " "1"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::size_type >(val1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vector_twa_graph" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::vector< spot::twa_graph_ptr > *)new std::vector< spot::twa_graph_ptr >(arg1,(std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_vector_twa_graph(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_vector_twa_graph", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_vector_twa_graph__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_vector_twa_graph__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_vector_twa_graph__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_vector_twa_graph__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_vector_twa_graph'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::twa_graph_ptr >::vector()\n"
    "    std::vector< spot::twa_graph_ptr >::vector(std::vector< spot::twa_graph_ptr > const &)\n"
    "    std::vector< spot::twa_graph_ptr >::vector(std::vector< std::shared_ptr< spot::twa_graph > >::size_type)\n"
    "    std::vector< spot::twa_graph_ptr >::vector(std::vector< std::shared_ptr< spot::twa_graph > >::size_type,std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_twa_graph_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_push_back" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vector_twa_graph_push_back" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp2);
      delete reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->push_back((std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_front" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = (std::vector< std::shared_ptr< spot::twa_graph > >::value_type *) &((std::vector< spot::twa_graph_ptr > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = *result ? new std::shared_ptr<  spot::twa_graph >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< std::shared_ptr< spot::twa_graph > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_back" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = (std::vector< std::shared_ptr< spot::twa_graph > >::value_type *) &((std::vector< spot::twa_graph_ptr > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = *result ? new std::shared_ptr<  spot::twa_graph >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  (void)swig::container_owner<swig::traits<std::vector< std::shared_ptr< spot::twa_graph > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::size_type arg2 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type tempshared3 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_twa_graph_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_assign" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph_assign" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_twa_graph_assign" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->assign(arg2,(std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::size_type arg2 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type tempshared3 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_resize" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph_resize" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::size_type >(val2);
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_twa_graph_resize" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      (arg1)->resize(arg2,(std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_twa_graph_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_vector_twa_graph_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_vector_twa_graph_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_twa_graph_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::twa_graph_ptr >::resize(std::vector< std::shared_ptr< spot::twa_graph > >::size_type)\n"
    "    std::vector< spot::twa_graph_ptr >::resize(std::vector< std::shared_ptr< spot::twa_graph > >::size_type,std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::iterator > arg2 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type tempshared3 ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::iterator > result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_insert" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(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 '" "vector_twa_graph_insert" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::shared_ptr< spot::twa_graph > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::shared_ptr< spot::twa_graph > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_twa_graph_insert" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::iterator""'");
    }
  }
  {
    int newmem = 0;
    res3 = SWIG_ConvertPtrAndOwn(swig_obj[2], &argp3, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_twa_graph_insert" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp3) tempshared3 = *reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3);
      delete reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3);
      arg3 = &tempshared3;
    } else {
      arg3 = (argp3) ? reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp3) : &tempshared3;
    }
  }
  {
    try {
      result = std_vector_Sl_spot_twa_graph_ptr_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::shared_ptr< spot::twa_graph > const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::shared_ptr< spot::twa_graph > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  SwigValueWrapper< std::vector< std::shared_ptr< spot::twa_graph > >::iterator > arg2 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::size_type arg3 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::value_type tempshared4 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_insert" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(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 '" "vector_twa_graph_insert" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::shared_ptr< spot::twa_graph > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::shared_ptr< spot::twa_graph > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vector_twa_graph_insert" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_twa_graph_insert" "', argument " "3"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::size_type >(val3);
  {
    int newmem = 0;
    res4 = SWIG_ConvertPtrAndOwn(swig_obj[3], &argp4, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_twa_graph_insert" "', argument " "4"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp4) tempshared4 = *reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp4);
      delete reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp4);
      arg4 = &tempshared4;
    } else {
      arg4 = (argp4) ? reinterpret_cast< std::vector< std::shared_ptr< spot::twa_graph > >::value_type * >(argp4) : &tempshared4;
    }
  }
  {
    try {
      std_vector_Sl_spot_twa_graph_ptr_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::shared_ptr< spot::twa_graph > const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "vector_twa_graph_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_vector_twa_graph_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_vector_twa_graph_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'vector_twa_graph_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::twa_graph_ptr >::insert(std::vector< std::shared_ptr< spot::twa_graph > >::iterator,std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &)\n"
    "    std::vector< spot::twa_graph_ptr >::insert(std::vector< std::shared_ptr< spot::twa_graph > >::iterator,std::vector< std::shared_ptr< spot::twa_graph > >::size_type,std::vector< std::shared_ptr< spot::twa_graph > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  std::vector< std::shared_ptr< spot::twa_graph > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "vector_twa_graph_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_reserve" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_twa_graph_reserve" "', argument " "2"" of type '" "std::vector< std::shared_ptr< spot::twa_graph > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::shared_ptr< spot::twa_graph > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vector_twa_graph_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::shared_ptr< spot::twa_graph > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_twa_graph_capacity" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      result = ((std::vector< spot::twa_graph_ptr > const *)arg1)->capacity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_vector_twa_graph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::twa_graph_ptr > *arg1 = (std::vector< spot::twa_graph_ptr > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vector_twa_graph" "', argument " "1"" of type '" "std::vector< spot::twa_graph_ptr > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::twa_graph_ptr > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *vector_twa_graph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *vector_twa_graph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_is_terminal_automaton__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::scc_info *arg2 = (spot::scc_info *) 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_terminal_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_terminal_automaton" "', argument " "2"" of type '" "spot::scc_info *""'"); 
  }
  arg2 = reinterpret_cast< spot::scc_info * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "is_terminal_automaton" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = (bool)spot::is_terminal_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_terminal_automaton__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::scc_info *arg2 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_terminal_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_terminal_automaton" "', argument " "2"" of type '" "spot::scc_info *""'"); 
  }
  arg2 = reinterpret_cast< spot::scc_info * >(argp2);
  {
    try {
      result = (bool)spot::is_terminal_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_terminal_automaton__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_terminal_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_terminal_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_terminal_automaton(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_terminal_automaton", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_is_terminal_automaton__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_is_terminal_automaton__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_is_terminal_automaton__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_terminal_automaton'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_terminal_automaton(spot::const_twa_graph_ptr const &,spot::scc_info *,bool)\n"
    "    spot::is_terminal_automaton(spot::const_twa_graph_ptr const &,spot::scc_info *)\n"
    "    spot::is_terminal_automaton(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_weak_automaton__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::scc_info *arg2 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_weak_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_weak_automaton" "', argument " "2"" of type '" "spot::scc_info *""'"); 
  }
  arg2 = reinterpret_cast< spot::scc_info * >(argp2);
  {
    try {
      result = (bool)spot::is_weak_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_weak_automaton__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_weak_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_weak_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_weak_automaton(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_weak_automaton", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_is_weak_automaton__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_is_weak_automaton__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_weak_automaton'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_weak_automaton(spot::const_twa_graph_ptr const &,spot::scc_info *)\n"
    "    spot::is_weak_automaton(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_very_weak_automaton__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::scc_info *arg2 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_very_weak_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_very_weak_automaton" "', argument " "2"" of type '" "spot::scc_info *""'"); 
  }
  arg2 = reinterpret_cast< spot::scc_info * >(argp2);
  {
    try {
      result = (bool)spot::is_very_weak_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_very_weak_automaton__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_very_weak_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_very_weak_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_very_weak_automaton(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_very_weak_automaton", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_is_very_weak_automaton__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_is_very_weak_automaton__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_very_weak_automaton'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_very_weak_automaton(spot::const_twa_graph_ptr const &,spot::scc_info *)\n"
    "    spot::is_very_weak_automaton(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_inherently_weak_automaton__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::scc_info *arg2 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_inherently_weak_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_inherently_weak_automaton" "', argument " "2"" of type '" "spot::scc_info *""'"); 
  }
  arg2 = reinterpret_cast< spot::scc_info * >(argp2);
  {
    try {
      result = (bool)spot::is_inherently_weak_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_inherently_weak_automaton__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_inherently_weak_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_inherently_weak_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_inherently_weak_automaton(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_inherently_weak_automaton", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_is_inherently_weak_automaton__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_is_inherently_weak_automaton__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_inherently_weak_automaton'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_inherently_weak_automaton(spot::const_twa_graph_ptr const &,spot::scc_info *)\n"
    "    spot::is_inherently_weak_automaton(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_safety_automaton__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::scc_info *arg2 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_safety_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_safety_automaton" "', argument " "2"" of type '" "spot::scc_info *""'"); 
  }
  arg2 = reinterpret_cast< spot::scc_info * >(argp2);
  {
    try {
      result = (bool)spot::is_safety_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_safety_automaton__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_safety_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_safety_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_safety_automaton(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_safety_automaton", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_is_safety_automaton__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_is_safety_automaton__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_safety_automaton'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_safety_automaton(spot::const_twa_graph_ptr const &,spot::scc_info *)\n"
    "    spot::is_safety_automaton(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_liveness_automaton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_liveness_automaton" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_liveness_automaton((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_strength__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  spot::scc_info *arg2 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "check_strength" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "check_strength" "', argument " "2"" of type '" "spot::scc_info *""'"); 
  }
  arg2 = reinterpret_cast< spot::scc_info * >(argp2);
  {
    try {
      spot::check_strength((std::shared_ptr< spot::twa_graph > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_strength__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "check_strength" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      spot::check_strength((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_strength(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "check_strength", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_check_strength__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_check_strength__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'check_strength'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::check_strength(spot::twa_graph_ptr const &,spot::scc_info *)\n"
    "    spot::check_strength(spot::twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_decompose_scc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "decompose_scc" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "decompose_scc" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::decompose_scc((std::shared_ptr< spot::twa_graph const > const &)*arg1,(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_decompose_scc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "decompose_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "decompose_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "decompose_scc" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::decompose_scc(*arg1,(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_decompose_strength(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::twa_graph_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "decompose_strength", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "decompose_strength" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "decompose_strength" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::decompose_strength((std::shared_ptr< spot::twa_graph const > const &)*arg1,(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_decompose_scc__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "decompose_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "decompose_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "decompose_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "decompose_scc" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::decompose_scc(*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_decompose_scc__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "decompose_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "decompose_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "decompose_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = spot::decompose_scc(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_decompose_scc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "decompose_scc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_decompose_scc__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_decompose_scc__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_decompose_scc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_decompose_scc__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'decompose_scc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::decompose_scc(spot::const_twa_graph_ptr const &,char const *)\n"
    "    spot::decompose_scc(spot::scc_info &,char const *)\n"
    "    spot::decompose_scc(spot::scc_info &,unsigned int,bool)\n"
    "    spot::decompose_scc(spot::scc_info &,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_scc_filter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  spot::scc_info *arg3 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_filter" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_filter" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "scc_filter" "', argument " "3"" of type '" "spot::scc_info *""'"); 
  }
  arg3 = reinterpret_cast< spot::scc_info * >(argp3);
  {
    try {
      result = spot::scc_filter((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_filter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_filter" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_filter" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::scc_filter((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_filter__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_filter" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::scc_filter((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_filter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "scc_filter", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_scc_filter__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_scc_filter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_scc_filter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'scc_filter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::scc_filter(spot::const_twa_graph_ptr const &,bool,spot::scc_info *)\n"
    "    spot::scc_filter(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::scc_filter(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_scc_filter_states__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  spot::scc_info *arg3 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_filter_states" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_filter_states" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "scc_filter_states" "', argument " "3"" of type '" "spot::scc_info *""'"); 
  }
  arg3 = reinterpret_cast< spot::scc_info * >(argp3);
  {
    try {
      result = spot::scc_filter_states((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_filter_states__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_filter_states" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_filter_states" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::scc_filter_states((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_filter_states__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_filter_states" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::scc_filter_states((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_filter_states(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "scc_filter_states", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_scc_filter_states__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_scc_filter_states__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_scc_filter_states__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'scc_filter_states'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::scc_filter_states(spot::const_twa_graph_ptr const &,bool,spot::scc_info *)\n"
    "    spot::scc_filter_states(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::scc_filter_states(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_scc_filter_susp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bdd arg3 ;
  bdd arg4 ;
  bool arg5 ;
  spot::scc_info *arg6 = (spot::scc_info *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_filter_susp" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_filter_susp" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "scc_filter_susp" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "scc_filter_susp" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "scc_filter_susp" "', argument " "4"" of type '" "bdd""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "scc_filter_susp" "', argument " "4"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "scc_filter_susp" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_spot__scc_info, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "scc_filter_susp" "', argument " "6"" of type '" "spot::scc_info *""'"); 
  }
  arg6 = reinterpret_cast< spot::scc_info * >(argp6);
  {
    try {
      result = spot::scc_filter_susp((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_filter_susp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bdd arg3 ;
  bdd arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_filter_susp" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_filter_susp" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "scc_filter_susp" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "scc_filter_susp" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "scc_filter_susp" "', argument " "4"" of type '" "bdd""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "scc_filter_susp" "', argument " "4"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "scc_filter_susp" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = spot::scc_filter_susp((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_filter_susp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "scc_filter_susp", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    PyObject *retobj = _wrap_scc_filter_susp__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_scc_filter_susp__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'scc_filter_susp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::scc_filter_susp(spot::const_twa_graph_ptr const &,bool,bdd,bdd,bool,spot::scc_info *)\n"
    "    spot::scc_filter_susp(spot::const_twa_graph_ptr const &,bool,bdd,bdd,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_statistics_edges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_statistics *arg1 = (spot::twa_statistics *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_statistics_edges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_statistics_edges_set" "', argument " "1"" of type '" "spot::twa_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_statistics * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_statistics_edges_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->edges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_statistics_edges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_statistics *arg1 = (spot::twa_statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_statistics_edges_get" "', argument " "1"" of type '" "spot::twa_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_statistics * >(argp1);
  result = (unsigned int) ((arg1)->edges);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_statistics_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_statistics *arg1 = (spot::twa_statistics *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_statistics_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_statistics_states_set" "', argument " "1"" of type '" "spot::twa_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_statistics * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_statistics_states_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_statistics_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_statistics *arg1 = (spot::twa_statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_statistics_states_get" "', argument " "1"" of type '" "spot::twa_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_statistics * >(argp1);
  result = (unsigned int) ((arg1)->states);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_statistics *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_twa_statistics", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::twa_statistics *)new spot::twa_statistics();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_statistics, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_statistics_dump(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_statistics *arg1 = (spot::twa_statistics *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_statistics_dump", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_statistics_dump" "', argument " "1"" of type '" "spot::twa_statistics const *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_statistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_statistics_dump" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_statistics_dump" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::twa_statistics const *)arg1)->dump(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_twa_statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_statistics *arg1 = (spot::twa_statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_statistics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_statistics" "', argument " "1"" of type '" "spot::twa_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_statistics * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_statistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__twa_statistics, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_statistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_twa_sub_statistics_transitions_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_sub_statistics *arg1 = (spot::twa_sub_statistics *) 0 ;
  unsigned long long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_sub_statistics_transitions_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_sub_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_sub_statistics_transitions_set" "', argument " "1"" of type '" "spot::twa_sub_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_sub_statistics * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twa_sub_statistics_transitions_set" "', argument " "2"" of type '" "unsigned long long""'");
  } 
  arg2 = static_cast< unsigned long long >(val2);
  if (arg1) (arg1)->transitions = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_sub_statistics_transitions_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_sub_statistics *arg1 = (spot::twa_sub_statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned long long result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_sub_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_sub_statistics_transitions_get" "', argument " "1"" of type '" "spot::twa_sub_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_sub_statistics * >(argp1);
  result = (unsigned long long) ((arg1)->transitions);
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_sub_statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_sub_statistics *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_twa_sub_statistics", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::twa_sub_statistics *)new spot::twa_sub_statistics();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_sub_statistics, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_sub_statistics_dump(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_sub_statistics *arg1 = (spot::twa_sub_statistics *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_sub_statistics_dump", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_sub_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_sub_statistics_dump" "', argument " "1"" of type '" "spot::twa_sub_statistics const *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_sub_statistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_sub_statistics_dump" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_sub_statistics_dump" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::twa_sub_statistics const *)arg1)->dump(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_twa_sub_statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_sub_statistics *arg1 = (spot::twa_sub_statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__twa_sub_statistics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_sub_statistics" "', argument " "1"" of type '" "spot::twa_sub_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::twa_sub_statistics * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_sub_statistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__twa_sub_statistics, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_sub_statistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_stats_reachable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  spot::twa_statistics result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stats_reachable" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::stats_reachable((std::shared_ptr< spot::twa const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::twa_statistics(result)), SWIGTYPE_p_spot__twa_statistics, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sub_stats_reachable(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_sub_statistics result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sub_stats_reachable" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::sub_stats_reachable((std::shared_ptr< spot::twa const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::twa_sub_statistics(result)), SWIGTYPE_p_spot__twa_sub_statistics, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_count_all_transitions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  unsigned long long result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "count_all_transitions" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (unsigned long long)spot::count_all_transitions((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_printable_formula__print(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_formula *arg1 = (spot::printable_formula *) 0 ;
  std::ostream *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "printable_formula__print", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_formula, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printable_formula__print" "', argument " "1"" of type '" "spot::printable_formula const *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_formula * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printable_formula__print" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "printable_formula__print" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "printable_formula__print" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      ((spot::printable_formula const *)arg1)->print(*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_printable_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_formula *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_printable_formula", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::printable_formula *)new spot::printable_formula();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__printable_formula, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_printable_formula(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_formula *arg1 = (spot::printable_formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_formula, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_printable_formula" "', argument " "1"" of type '" "spot::printable_formula *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_formula * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *printable_formula_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__printable_formula, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *printable_formula_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_printable_acc_cond__print(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_acc_cond *arg1 = (spot::printable_acc_cond *) 0 ;
  std::ostream *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "printable_acc_cond__print", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_acc_cond, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printable_acc_cond__print" "', argument " "1"" of type '" "spot::printable_acc_cond const *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_acc_cond * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printable_acc_cond__print" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "printable_acc_cond__print" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "printable_acc_cond__print" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      ((spot::printable_acc_cond const *)arg1)->print(*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_printable_acc_cond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_acc_cond *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_printable_acc_cond", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::printable_acc_cond *)new spot::printable_acc_cond();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__printable_acc_cond, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_printable_acc_cond(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_acc_cond *arg1 = (spot::printable_acc_cond *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_acc_cond, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_printable_acc_cond" "', argument " "1"" of type '" "spot::printable_acc_cond *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_acc_cond * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *printable_acc_cond_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__printable_acc_cond, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *printable_acc_cond_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_printable_scc_info_automaton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_scc_info *arg1 = (spot::printable_scc_info *) 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "printable_scc_info_automaton", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printable_scc_info_automaton" "', argument " "1"" of type '" "spot::printable_scc_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_scc_info * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printable_scc_info_automaton" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      (arg1)->automaton((spot::const_twa_graph_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_printable_scc_info_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_scc_info *arg1 = (spot::printable_scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printable_scc_info_reset" "', argument " "1"" of type '" "spot::printable_scc_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_scc_info * >(argp1);
  {
    try {
      (arg1)->reset();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_printable_scc_info__print(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_scc_info *arg1 = (spot::printable_scc_info *) 0 ;
  std::ostream *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "printable_scc_info__print", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_scc_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printable_scc_info__print" "', argument " "1"" of type '" "spot::printable_scc_info const *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_scc_info * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printable_scc_info__print" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "printable_scc_info__print" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "printable_scc_info__print" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      ((spot::printable_scc_info const *)arg1)->print(*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_printable_scc_info(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_scc_info *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_printable_scc_info", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::printable_scc_info *)new spot::printable_scc_info();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__printable_scc_info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_printable_scc_info(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_scc_info *arg1 = (spot::printable_scc_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_scc_info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_printable_scc_info" "', argument " "1"" of type '" "spot::printable_scc_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_scc_info * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *printable_scc_info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__printable_scc_info, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *printable_scc_info_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_printable_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_size *arg1 = (spot::printable_size *) 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 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "printable_size_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_size, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printable_size_set" "', argument " "1"" of type '" "spot::printable_size *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_size * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "printable_size_set" "', 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 '" "printable_size_set" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      (arg1)->set(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_printable_size__print(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_size *arg1 = (spot::printable_size *) 0 ;
  std::ostream *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "printable_size__print", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_size, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printable_size__print" "', argument " "1"" of type '" "spot::printable_size const *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_size * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printable_size__print" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "printable_size__print" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "printable_size__print" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      ((spot::printable_size const *)arg1)->print(*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_printable_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_size *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_printable_size", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::printable_size *)new spot::printable_size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__printable_size, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_printable_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_size *arg1 = (spot::printable_size *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_size, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_printable_size" "', argument " "1"" of type '" "spot::printable_size *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_size * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *printable_size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__printable_size, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *printable_size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_printable_long_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_long_size *arg1 = (spot::printable_long_size *) 0 ;
  unsigned long long arg2 ;
  unsigned long long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "printable_long_size_set", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_long_size, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printable_long_size_set" "', argument " "1"" of type '" "spot::printable_long_size *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_long_size * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "printable_long_size_set" "', argument " "2"" of type '" "unsigned long long""'");
  } 
  arg2 = static_cast< unsigned long long >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "printable_long_size_set" "', argument " "3"" of type '" "unsigned long long""'");
  } 
  arg3 = static_cast< unsigned long long >(val3);
  {
    try {
      (arg1)->set(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_printable_long_size__print(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_long_size *arg1 = (spot::printable_long_size *) 0 ;
  std::ostream *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "printable_long_size__print", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_long_size, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "printable_long_size__print" "', argument " "1"" of type '" "spot::printable_long_size const *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_long_size * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "printable_long_size__print" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "printable_long_size__print" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "printable_long_size__print" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      ((spot::printable_long_size const *)arg1)->print(*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_printable_long_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_long_size *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_printable_long_size", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::printable_long_size *)new spot::printable_long_size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__printable_long_size, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_printable_long_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::printable_long_size *arg1 = (spot::printable_long_size *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__printable_long_size, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_printable_long_size" "', argument " "1"" of type '" "spot::printable_long_size *""'"); 
  }
  arg1 = reinterpret_cast< spot::printable_long_size * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *printable_long_size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__printable_long_size, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *printable_long_size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_stat_printer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::stat_printer *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_stat_printer", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_stat_printer" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_stat_printer" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_stat_printer" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (spot::stat_printer *)new spot::stat_printer(*arg1,(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__stat_printer, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_stat_printer__print__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::stat_printer *arg1 = (spot::stat_printer *) 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  spot::formula arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__stat_printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stat_printer__print" "', argument " "1"" of type '" "spot::stat_printer *""'"); 
  }
  arg1 = reinterpret_cast< spot::stat_printer * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "stat_printer__print" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "stat_printer__print" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  {
    try {
      result = (std::ostream *) &(arg1)->print((spot::const_twa_graph_ptr const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stat_printer__print__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::stat_printer *arg1 = (spot::stat_printer *) 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__stat_printer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stat_printer__print" "', argument " "1"" of type '" "spot::stat_printer *""'"); 
  }
  arg1 = reinterpret_cast< spot::stat_printer * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "stat_printer__print" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::ostream *) &(arg1)->print((spot::const_twa_graph_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stat_printer__print(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "stat_printer__print", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_stat_printer__print__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_stat_printer__print__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'stat_printer__print'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::stat_printer::print(spot::const_twa_graph_ptr const &,spot::formula)\n"
    "    spot::stat_printer::print(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_stat_printer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::stat_printer *arg1 = (spot::stat_printer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__stat_printer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_stat_printer" "', argument " "1"" of type '" "spot::stat_printer *""'"); 
  }
  arg1 = reinterpret_cast< spot::stat_printer * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *stat_printer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__stat_printer, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *stat_printer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_count_nondet_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "count_nondet_states" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (unsigned int)spot::count_nondet_states((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_universal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_universal" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_universal((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_deterministic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_deterministic" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_deterministic((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_nondet_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "highlight_nondet_states", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_nondet_states" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "highlight_nondet_states" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      spot::highlight_nondet_states(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_nondet_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "highlight_nondet_edges", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_nondet_edges" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "highlight_nondet_edges" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      spot::highlight_nondet_edges(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_semidet_sccs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "highlight_semidet_sccs", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_semidet_sccs" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "highlight_semidet_sccs" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "highlight_semidet_sccs" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      spot::highlight_semidet_sccs(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_complete(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_complete" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_complete((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_semi_deterministic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_semi_deterministic" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_semi_deterministic((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_semidet_sccs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< bool,std::allocator< bool > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "semidet_sccs" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "semidet_sccs" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = spot::semidet_sccs(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_determinism(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "check_determinism" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      spot::check_determinism(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_count_univbranch_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "count_univbranch_states" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (unsigned int)spot::count_univbranch_states((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_count_univbranch_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "count_univbranch_edges" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (unsigned int)spot::count_univbranch_edges((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_colored(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_colored" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_colored((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_unambiguous(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_unambiguous" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::is_unambiguous((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_unambiguous(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "check_unambiguous" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::check_unambiguous((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scc_has_rejecting_cycle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "scc_has_rejecting_cycle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scc_has_rejecting_cycle" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "scc_has_rejecting_cycle" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scc_has_rejecting_cycle" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)spot::scc_has_rejecting_cycle(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_inherently_weak_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "is_inherently_weak_scc", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_inherently_weak_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "is_inherently_weak_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "is_inherently_weak_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)spot::is_inherently_weak_scc(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_weak_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "is_weak_scc", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_weak_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "is_weak_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "is_weak_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)spot::is_weak_scc(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_complete_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "is_complete_scc", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_complete_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "is_complete_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "is_complete_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)spot::is_complete_scc(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_terminal_scc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "is_terminal_scc", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_terminal_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "is_terminal_scc" "', argument " "1"" of type '" "spot::scc_info &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "is_terminal_scc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)spot::is_terminal_scc(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_alternate_players__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "alternate_players" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "alternate_players" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "alternate_players" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      spot::alternate_players(*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_alternate_players__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "alternate_players" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "alternate_players" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      spot::alternate_players(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_alternate_players__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "alternate_players" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      spot::alternate_players(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_alternate_players(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "alternate_players", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_alternate_players__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_alternate_players__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_alternate_players__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'alternate_players'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::alternate_players(spot::twa_graph_ptr &,bool,bool)\n"
    "    spot::alternate_players(spot::twa_graph_ptr &,bool)\n"
    "    spot::alternate_players(spot::twa_graph_ptr &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_solve_parity_game(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solve_parity_game" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::solve_parity_game((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_solve_safety_game(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solve_safety_game" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::solve_safety_game((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_solve_game__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solve_game" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (bool)spot::solve_game((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_pg(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "print_pg", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_pg" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_pg" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_pg" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::print_pg(*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pg_print(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pg_print", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pg_print" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "pg_print" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pg_print" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      spot::pg_print(*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_strategy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_strategy" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "highlight_strategy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "highlight_strategy" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = spot::highlight_strategy(*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_strategy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_strategy" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "highlight_strategy" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = spot::highlight_strategy(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_strategy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_strategy" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::highlight_strategy(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_strategy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "highlight_strategy", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_highlight_strategy__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_highlight_strategy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_highlight_strategy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'highlight_strategy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::highlight_strategy(spot::twa_graph_ptr &,int,int)\n"
    "    spot::highlight_strategy(spot::twa_graph_ptr &,int)\n"
    "    spot::highlight_strategy(spot::twa_graph_ptr &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_set_state_players__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::region_t *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_state_players" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_state_players" "', argument " "2"" of type '" "spot::region_t const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_state_players" "', argument " "2"" of type '" "spot::region_t const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      spot::set_state_players(SWIG_STD_MOVE(arg1),(std::vector< bool,std::allocator< bool > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_state_players__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::region_t *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::unique_ptr< spot::region_t > rvrdeleter2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_state_players" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res2)) {
    if (res2 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_state_players" "', cannot release ownership as memory is not owned for argument " "2"" of type '" "spot::region_t &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_state_players" "', argument " "2"" of type '" "spot::region_t &&""'"); 
    }
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_state_players" "', argument " "2"" of type '" "spot::region_t &&""'"); 
  }
  arg2 = reinterpret_cast< spot::region_t * >(argp2);
  rvrdeleter2.reset(arg2);
  {
    try {
      spot::set_state_players(SWIG_STD_MOVE(arg1),(std::vector< bool,std::allocator< bool > > &&)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_state_players(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "set_state_players", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_set_state_players__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_set_state_players__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'set_state_players'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::set_state_players(spot::twa_graph_ptr,spot::region_t const &)\n"
    "    spot::set_state_players(spot::twa_graph_ptr,spot::region_t &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_set_state_player(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  unsigned int arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "set_state_player", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_state_player" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set_state_player" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "set_state_player" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      spot::set_state_player(SWIG_STD_MOVE(arg1),arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_state_player(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "get_state_player", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_state_player" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_state_player" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)spot::get_state_player(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_state_players__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::region_t *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_state_players" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::region_t *) &spot::get_state_players((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_state_players__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  spot::region_t *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_state_players" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::region_t *) &spot::get_state_players(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_state_players(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "get_state_players", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_get_state_players__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_get_state_players__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'get_state_players'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::get_state_players(spot::const_twa_graph_ptr const &)\n"
    "    spot::get_state_players(spot::twa_graph_ptr &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_get_strategy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::strategy_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_strategy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::strategy_t *) &spot::get_strategy((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_strategy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::strategy_t *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_strategy" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    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 '" "set_strategy" "', argument " "2"" of type '" "spot::strategy_t const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_strategy" "', argument " "2"" of type '" "spot::strategy_t const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      spot::set_strategy(SWIG_STD_MOVE(arg1),(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_strategy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::strategy_t *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::unique_ptr< spot::strategy_t > rvrdeleter2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_strategy" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res2)) {
    if (res2 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_strategy" "', cannot release ownership as memory is not owned for argument " "2"" of type '" "spot::strategy_t &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_strategy" "', argument " "2"" of type '" "spot::strategy_t &&""'"); 
    }
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_strategy" "', argument " "2"" of type '" "spot::strategy_t &&""'"); 
  }
  arg2 = reinterpret_cast< spot::strategy_t * >(argp2);
  rvrdeleter2.reset(arg2);
  {
    try {
      spot::set_strategy(SWIG_STD_MOVE(arg1),(std::vector< unsigned int,std::allocator< unsigned int > > &&)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_strategy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "set_strategy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_set_strategy__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_set_strategy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'set_strategy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::set_strategy(spot::twa_graph_ptr,spot::strategy_t const &)\n"
    "    spot::set_strategy(spot::twa_graph_ptr,spot::strategy_t &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_set_synthesis_outputs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bdd *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "set_synthesis_outputs", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_synthesis_outputs" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_synthesis_outputs" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_synthesis_outputs" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  {
    try {
      spot::set_synthesis_outputs((std::shared_ptr< spot::twa_graph > const &)*arg1,(bdd const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_synthesis_outputs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  bdd result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_synthesis_outputs" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::get_synthesis_outputs((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_synthesis_output_aps(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_synthesis_output_aps" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::get_synthesis_output_aps((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_state_winners__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::region_t *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_state_winners" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_state_winners" "', argument " "2"" of type '" "spot::region_t const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_state_winners" "', argument " "2"" of type '" "spot::region_t const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      spot::set_state_winners(SWIG_STD_MOVE(arg1),(std::vector< bool,std::allocator< bool > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_state_winners__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::region_t *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::unique_ptr< spot::region_t > rvrdeleter2 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_state_winners" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_RELEASE |  0 );
  if (!SWIG_IsOK(res2)) {
    if (res2 == SWIG_ERROR_RELEASE_NOT_OWNED) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_state_winners" "', cannot release ownership as memory is not owned for argument " "2"" of type '" "spot::region_t &&""'");
    } else {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "set_state_winners" "', argument " "2"" of type '" "spot::region_t &&""'"); 
    }
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "set_state_winners" "', argument " "2"" of type '" "spot::region_t &&""'"); 
  }
  arg2 = reinterpret_cast< spot::region_t * >(argp2);
  rvrdeleter2.reset(arg2);
  {
    try {
      spot::set_state_winners(SWIG_STD_MOVE(arg1),(std::vector< bool,std::allocator< bool > > &&)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_state_winners(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "set_state_winners", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_set_state_winners__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_set_state_winners__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'set_state_winners'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::set_state_winners(spot::twa_graph_ptr,spot::region_t const &)\n"
    "    spot::set_state_winners(spot::twa_graph_ptr,spot::region_t &&)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_set_state_winner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  unsigned int arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "set_state_winner", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_state_winner" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "set_state_winner" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "set_state_winner" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      spot::set_state_winner(SWIG_STD_MOVE(arg1),arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_state_winner(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "get_state_winner", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_state_winner" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_state_winner" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)spot::get_state_winner(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_state_winners(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::region_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_state_winners" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::region_t *) &spot::get_state_winners((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simulation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simulation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simulation" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = spot::simulation((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simulation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simulation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::simulation((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simulation__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  std::vector< bdd,std::allocator< bdd > > *arg2 = (std::vector< bdd,std::allocator< bdd > > *) 0 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simulation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "simulation" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bdd,std::allocator< bdd > > * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "simulation" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = spot::simulation((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simulation__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  std::vector< bdd,std::allocator< bdd > > *arg2 = (std::vector< bdd,std::allocator< bdd > > *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simulation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "simulation" "', argument " "2"" of type '" "std::vector< bdd,std::allocator< bdd > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< bdd,std::allocator< bdd > > * >(argp2);
  {
    try {
      result = spot::simulation((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simulation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "simulation", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_simulation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_simulation__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_simulation__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_simulation__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'simulation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::simulation(spot::const_twa_graph_ptr const &,int)\n"
    "    spot::simulation(spot::const_twa_graph_ptr const &)\n"
    "    spot::simulation(spot::const_twa_graph_ptr const &,std::vector< bdd,std::allocator< bdd > > *,int)\n"
    "    spot::simulation(spot::const_twa_graph_ptr const &,std::vector< bdd,std::allocator< bdd > > *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_simulation_sba__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simulation_sba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "simulation_sba" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = spot::simulation_sba((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simulation_sba__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simulation_sba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::simulation_sba((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simulation_sba(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "simulation_sba", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_simulation_sba__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_simulation_sba__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'simulation_sba'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::simulation_sba(spot::const_twa_graph_ptr const &,int)\n"
    "    spot::simulation_sba(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_cosimulation__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cosimulation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cosimulation" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = spot::cosimulation((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cosimulation__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cosimulation" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::cosimulation((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cosimulation(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "cosimulation", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_cosimulation__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_cosimulation__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'cosimulation'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::cosimulation(spot::const_twa_graph_ptr const &,int)\n"
    "    spot::cosimulation(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_cosimulation_sba__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cosimulation_sba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cosimulation_sba" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = spot::cosimulation_sba((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cosimulation_sba__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cosimulation_sba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::cosimulation_sba((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cosimulation_sba(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "cosimulation_sba", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_cosimulation_sba__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_cosimulation_sba__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'cosimulation_sba'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::cosimulation_sba(spot::const_twa_graph_ptr const &,int)\n"
    "    spot::cosimulation_sba(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_iterated_simulations__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iterated_simulations" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iterated_simulations" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = spot::iterated_simulations((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iterated_simulations__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iterated_simulations" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::iterated_simulations((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iterated_simulations(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "iterated_simulations", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_iterated_simulations__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_iterated_simulations__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'iterated_simulations'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::iterated_simulations(spot::const_twa_graph_ptr const &,int)\n"
    "    spot::iterated_simulations(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_iterated_simulations_sba__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iterated_simulations_sba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iterated_simulations_sba" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = spot::iterated_simulations_sba((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iterated_simulations_sba__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iterated_simulations_sba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::iterated_simulations_sba((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iterated_simulations_sba(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "iterated_simulations_sba", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_iterated_simulations_sba__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_iterated_simulations_sba__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'iterated_simulations_sba'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::iterated_simulations_sba(spot::const_twa_graph_ptr const &,int)\n"
    "    spot::iterated_simulations_sba(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_reduce_direct_sim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_direct_sim" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::reduce_direct_sim((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_direct_sim_sba(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_direct_sim_sba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::reduce_direct_sim_sba((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_direct_cosim(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_direct_cosim" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::reduce_direct_cosim((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_direct_cosim_sba(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_direct_cosim_sba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::reduce_direct_cosim_sba((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_iterated(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_iterated" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::reduce_iterated((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_iterated_sba(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_iterated_sba" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::reduce_iterated_sba((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_change_parity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::parity_kind arg2 ;
  spot::parity_style arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::twa_graph_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "change_parity", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "change_parity" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "change_parity" "', argument " "2"" of type '" "spot::parity_kind""'");
  } 
  arg2 = static_cast< spot::parity_kind >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "change_parity" "', argument " "3"" of type '" "spot::parity_style""'");
  } 
  arg3 = static_cast< spot::parity_style >(val3);
  {
    try {
      result = spot::change_parity((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_change_parity_here(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::parity_kind arg2 ;
  spot::parity_style arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::twa_graph_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "change_parity_here", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "change_parity_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "change_parity_here" "', argument " "2"" of type '" "spot::parity_kind""'");
  } 
  arg2 = static_cast< spot::parity_kind >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "change_parity_here" "', argument " "3"" of type '" "spot::parity_style""'");
  } 
  arg3 = static_cast< spot::parity_style >(val3);
  {
    try {
      result = spot::change_parity_here(SWIG_STD_MOVE(arg1),arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanup_parity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cleanup_parity" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cleanup_parity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::cleanup_parity((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanup_parity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cleanup_parity" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::cleanup_parity((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanup_parity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "cleanup_parity", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_cleanup_parity__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_cleanup_parity__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'cleanup_parity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::cleanup_parity(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::cleanup_parity(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_cleanup_parity_here__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cleanup_parity_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cleanup_parity_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::cleanup_parity_here(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanup_parity_here__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cleanup_parity_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::cleanup_parity_here(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cleanup_parity_here(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "cleanup_parity_here", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_cleanup_parity_here__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_cleanup_parity_here__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'cleanup_parity_here'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::cleanup_parity_here(spot::twa_graph_ptr,bool)\n"
    "    spot::cleanup_parity_here(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_colorize_parity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorize_parity" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorize_parity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::colorize_parity((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_colorize_parity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorize_parity" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::colorize_parity((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_colorize_parity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "colorize_parity", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_colorize_parity__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_colorize_parity__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'colorize_parity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::colorize_parity(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::colorize_parity(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_colorize_parity_here__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorize_parity_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorize_parity_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::colorize_parity_here(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_colorize_parity_here__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorize_parity_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::colorize_parity_here(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_colorize_parity_here(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "colorize_parity_here", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_colorize_parity_here__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_colorize_parity_here__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'colorize_parity_here'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::colorize_parity_here(spot::twa_graph_ptr,bool)\n"
    "    spot::colorize_parity_here(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_reduce_parity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reduce_parity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "reduce_parity" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::reduce_parity((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reduce_parity" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::reduce_parity((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::reduce_parity((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "reduce_parity", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_reduce_parity__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_reduce_parity__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_reduce_parity__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'reduce_parity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::reduce_parity(spot::const_twa_graph_ptr const &,bool,bool)\n"
    "    spot::reduce_parity(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::reduce_parity(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_reduce_parity_here__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reduce_parity_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "reduce_parity_here" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::reduce_parity_here(SWIG_STD_MOVE(arg1),arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity_here__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reduce_parity_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::reduce_parity_here(SWIG_STD_MOVE(arg1),arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity_here__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_here" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::reduce_parity_here(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity_here(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "reduce_parity_here", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_reduce_parity_here__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_reduce_parity_here__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_reduce_parity_here__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'reduce_parity_here'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::reduce_parity_here(spot::twa_graph_ptr,bool,bool)\n"
    "    spot::reduce_parity_here(spot::twa_graph_ptr,bool)\n"
    "    spot::reduce_parity_here(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_reduce_parity_data_parity_max_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::reduce_parity_data *arg1 = (spot::reduce_parity_data *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "reduce_parity_data_parity_max_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__reduce_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_data_parity_max_set" "', argument " "1"" of type '" "spot::reduce_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::reduce_parity_data * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reduce_parity_data_parity_max_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->parity_max = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity_data_parity_max_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::reduce_parity_data *arg1 = (spot::reduce_parity_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__reduce_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_data_parity_max_get" "', argument " "1"" of type '" "spot::reduce_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::reduce_parity_data * >(argp1);
  result = (bool) ((arg1)->parity_max);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity_data_parity_odd_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::reduce_parity_data *arg1 = (spot::reduce_parity_data *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "reduce_parity_data_parity_odd_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__reduce_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_data_parity_odd_set" "', argument " "1"" of type '" "spot::reduce_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::reduce_parity_data * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reduce_parity_data_parity_odd_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->parity_odd = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity_data_parity_odd_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::reduce_parity_data *arg1 = (spot::reduce_parity_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__reduce_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_data_parity_odd_get" "', argument " "1"" of type '" "spot::reduce_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::reduce_parity_data * >(argp1);
  result = (bool) ((arg1)->parity_odd);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity_data_piprime1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::reduce_parity_data *arg1 = (spot::reduce_parity_data *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "reduce_parity_data_piprime1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__reduce_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_data_piprime1_set" "', argument " "1"" of type '" "spot::reduce_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::reduce_parity_data * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "reduce_parity_data_piprime1_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->piprime1 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity_data_piprime1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::reduce_parity_data *arg1 = (spot::reduce_parity_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__reduce_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_data_piprime1_get" "', argument " "1"" of type '" "spot::reduce_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::reduce_parity_data * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->piprime1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity_data_piprime2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::reduce_parity_data *arg1 = (spot::reduce_parity_data *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "reduce_parity_data_piprime2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__reduce_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_data_piprime2_set" "', argument " "1"" of type '" "spot::reduce_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::reduce_parity_data * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "reduce_parity_data_piprime2_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->piprime2 = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_reduce_parity_data_piprime2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::reduce_parity_data *arg1 = (spot::reduce_parity_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__reduce_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reduce_parity_data_piprime2_get" "', argument " "1"" of type '" "spot::reduce_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::reduce_parity_data * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->piprime2);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_reduce_parity_data__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::reduce_parity_data *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_reduce_parity_data" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_reduce_parity_data" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = (spot::reduce_parity_data *)new spot::reduce_parity_data((spot::const_twa_graph_ptr const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__reduce_parity_data, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_reduce_parity_data__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::reduce_parity_data *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_reduce_parity_data" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::reduce_parity_data *)new spot::reduce_parity_data((spot::const_twa_graph_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__reduce_parity_data, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_reduce_parity_data(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_reduce_parity_data", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_reduce_parity_data__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_reduce_parity_data__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_reduce_parity_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::reduce_parity_data::reduce_parity_data(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::reduce_parity_data::reduce_parity_data(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_reduce_parity_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::reduce_parity_data *arg1 = (spot::reduce_parity_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__reduce_parity_data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_reduce_parity_data" "', argument " "1"" of type '" "spot::reduce_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::reduce_parity_data * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *reduce_parity_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__reduce_parity_data, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *reduce_parity_data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_postprocessor__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::postprocessor *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_postprocessor" "', argument " "1"" of type '" "spot::option_map const *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  {
    try {
      result = (spot::postprocessor *)new spot::postprocessor((spot::option_map const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__postprocessor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_postprocessor__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::postprocessor *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::postprocessor *)new spot::postprocessor();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__postprocessor, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_postprocessor(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_postprocessor", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_postprocessor__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_new_postprocessor__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_postprocessor'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::postprocessor::postprocessor(spot::option_map const *)\n"
    "    spot::postprocessor::postprocessor()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_postprocessor_set_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::postprocessor *arg1 = (spot::postprocessor *) 0 ;
  spot::postprocessor::output_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "postprocessor_set_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__postprocessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "postprocessor_set_type" "', argument " "1"" of type '" "spot::postprocessor *""'"); 
  }
  arg1 = reinterpret_cast< spot::postprocessor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "postprocessor_set_type" "', argument " "2"" of type '" "spot::postprocessor::output_type""'");
  } 
  arg2 = static_cast< spot::postprocessor::output_type >(val2);
  {
    try {
      (arg1)->set_type(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_postprocessor_set_pref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::postprocessor *arg1 = (spot::postprocessor *) 0 ;
  spot::postprocessor::output_pref arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "postprocessor_set_pref", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__postprocessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "postprocessor_set_pref" "', argument " "1"" of type '" "spot::postprocessor *""'"); 
  }
  arg1 = reinterpret_cast< spot::postprocessor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "postprocessor_set_pref" "', argument " "2"" of type '" "spot::postprocessor::output_pref""'");
  } 
  arg2 = static_cast< spot::postprocessor::output_pref >(val2);
  {
    try {
      (arg1)->set_pref(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_postprocessor_set_level(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::postprocessor *arg1 = (spot::postprocessor *) 0 ;
  spot::postprocessor::optimization_level arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "postprocessor_set_level", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__postprocessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "postprocessor_set_level" "', argument " "1"" of type '" "spot::postprocessor *""'"); 
  }
  arg1 = reinterpret_cast< spot::postprocessor * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "postprocessor_set_level" "', argument " "2"" of type '" "spot::postprocessor::optimization_level""'");
  } 
  arg2 = static_cast< spot::postprocessor::optimization_level >(val2);
  {
    try {
      (arg1)->set_level(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_postprocessor_run__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::postprocessor *arg1 = (spot::postprocessor *) 0 ;
  spot::twa_graph_ptr arg2 ;
  spot::formula arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__postprocessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "postprocessor_run" "', argument " "1"" of type '" "spot::postprocessor *""'"); 
  }
  arg1 = reinterpret_cast< spot::postprocessor * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "postprocessor_run" "', argument " "2"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[2], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "postprocessor_run" "', argument " "3"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg3 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg3 is fine.
  }
  {
    try {
      result = (arg1)->run(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_postprocessor_run__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::postprocessor *arg1 = (spot::postprocessor *) 0 ;
  spot::twa_graph_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__postprocessor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "postprocessor_run" "', argument " "1"" of type '" "spot::postprocessor *""'"); 
  }
  arg1 = reinterpret_cast< spot::postprocessor * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "postprocessor_run" "', argument " "2"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (arg1)->run(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_postprocessor_run(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "postprocessor_run", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_postprocessor_run__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_postprocessor_run__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'postprocessor_run'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::postprocessor::run(spot::twa_graph_ptr,spot::formula)\n"
    "    spot::postprocessor::run(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_postprocessor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::postprocessor *arg1 = (spot::postprocessor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__postprocessor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_postprocessor" "', argument " "1"" of type '" "spot::postprocessor *""'"); 
  }
  arg1 = reinterpret_cast< spot::postprocessor * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *postprocessor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__postprocessor, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *postprocessor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_power_map_map__set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::power_map *arg1 = (spot::power_map *) 0 ;
  std::vector< spot::power_map::power_state,std::allocator< spot::power_map::power_state > > *arg2 = (std::vector< spot::power_map::power_state,std::allocator< spot::power_map::power_state > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "power_map_map__set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__power_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "power_map_map__set" "', argument " "1"" of type '" "spot::power_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::power_map * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_std__allocatorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "power_map_map__set" "', argument " "2"" of type '" "std::vector< spot::power_map::power_state,std::allocator< spot::power_map::power_state > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::power_map::power_state,std::allocator< spot::power_map::power_state > > * >(argp2);
  if (arg1) (arg1)->map_ = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_power_map_map__get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::power_map *arg1 = (spot::power_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::power_map::power_state,std::allocator< spot::power_map::power_state > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__power_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "power_map_map__get" "', argument " "1"" of type '" "spot::power_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::power_map * >(argp1);
  result = (std::vector< spot::power_map::power_state,std::allocator< spot::power_map::power_state > > *)& ((arg1)->map_);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_std__allocatorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_power_map_states_of(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::power_map *arg1 = (spot::power_map *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::power_map::power_state *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "power_map_states_of", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__power_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "power_map_states_of" "', argument " "1"" of type '" "spot::power_map const *""'"); 
  }
  arg1 = reinterpret_cast< spot::power_map * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "power_map_states_of" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::power_map::power_state *) &((spot::power_map const *)arg1)->states_of(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_power_map(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::power_map *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_power_map", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::power_map *)new spot::power_map();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__power_map, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_power_map(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::power_map *arg1 = (spot::power_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__power_map, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_power_map" "', argument " "1"" of type '" "spot::power_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::power_map * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *power_map_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__power_map, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *power_map_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_output_aborter__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 ;
  spot::output_aborter *result = 0 ;
  
  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 '" "new_output_aborter" "', 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 '" "new_output_aborter" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::output_aborter *)new spot::output_aborter(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__output_aborter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_output_aborter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  spot::output_aborter *result = 0 ;
  
  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 '" "new_output_aborter" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      result = (spot::output_aborter *)new spot::output_aborter(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__output_aborter, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_output_aborter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_output_aborter", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_output_aborter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_output_aborter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_output_aborter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::output_aborter::output_aborter(unsigned int,unsigned int)\n"
    "    spot::output_aborter::output_aborter(unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_output_aborter_max_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::output_aborter *arg1 = (spot::output_aborter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "output_aborter_max_states" "', argument " "1"" of type '" "spot::output_aborter const *""'"); 
  }
  arg1 = reinterpret_cast< spot::output_aborter * >(argp1);
  {
    try {
      result = (unsigned int)((spot::output_aborter const *)arg1)->max_states();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_output_aborter_max_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::output_aborter *arg1 = (spot::output_aborter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "output_aborter_max_edges" "', argument " "1"" of type '" "spot::output_aborter const *""'"); 
  }
  arg1 = reinterpret_cast< spot::output_aborter * >(argp1);
  {
    try {
      result = (unsigned int)((spot::output_aborter const *)arg1)->max_edges();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_output_aborter_too_large(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::output_aborter *arg1 = (spot::output_aborter *) 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "output_aborter_too_large", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "output_aborter_too_large" "', argument " "1"" of type '" "spot::output_aborter const *""'"); 
  }
  arg1 = reinterpret_cast< spot::output_aborter * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "output_aborter_too_large" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (bool)((spot::output_aborter const *)arg1)->too_large((spot::const_twa_graph_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_output_aborter_print_reason(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::output_aborter *arg1 = (spot::output_aborter *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "output_aborter_print_reason", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "output_aborter_print_reason" "', argument " "1"" of type '" "spot::output_aborter const *""'"); 
  }
  arg1 = reinterpret_cast< spot::output_aborter * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "output_aborter_print_reason" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "output_aborter_print_reason" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::output_aborter const *)arg1)->print_reason(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_output_aborter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::output_aborter *arg1 = (spot::output_aborter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__output_aborter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_output_aborter" "', argument " "1"" of type '" "spot::output_aborter *""'"); 
  }
  arg1 = reinterpret_cast< spot::output_aborter * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *output_aborter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__output_aborter, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *output_aborter_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_tgba_powerset__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::power_map *arg2 = 0 ;
  bool arg3 ;
  spot::output_aborter *arg4 = (spot::output_aborter *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg5 = (std::vector< unsigned int,std::allocator< unsigned int > > *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_powerset" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__power_map,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_powerset" "', argument " "2"" of type '" "spot::power_map &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_powerset" "', argument " "2"" of type '" "spot::power_map &""'"); 
  }
  arg2 = reinterpret_cast< spot::power_map * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_powerset" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "tgba_powerset" "', argument " "4"" of type '" "spot::output_aborter const *""'"); 
  }
  arg4 = reinterpret_cast< spot::output_aborter * >(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "tgba_powerset" "', argument " "5"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > *""'"); 
  }
  arg5 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp5);
  {
    try {
      result = spot::tgba_powerset((std::shared_ptr< spot::twa_graph const > const &)*arg1,*arg2,arg3,(spot::output_aborter const *)arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_powerset__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::power_map *arg2 = 0 ;
  bool arg3 ;
  spot::output_aborter *arg4 = (spot::output_aborter *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_powerset" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__power_map,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_powerset" "', argument " "2"" of type '" "spot::power_map &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_powerset" "', argument " "2"" of type '" "spot::power_map &""'"); 
  }
  arg2 = reinterpret_cast< spot::power_map * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_powerset" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "tgba_powerset" "', argument " "4"" of type '" "spot::output_aborter const *""'"); 
  }
  arg4 = reinterpret_cast< spot::output_aborter * >(argp4);
  {
    try {
      result = spot::tgba_powerset((std::shared_ptr< spot::twa_graph const > const &)*arg1,*arg2,arg3,(spot::output_aborter const *)arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_powerset__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::power_map *arg2 = 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_powerset" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__power_map,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_powerset" "', argument " "2"" of type '" "spot::power_map &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_powerset" "', argument " "2"" of type '" "spot::power_map &""'"); 
  }
  arg2 = reinterpret_cast< spot::power_map * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_powerset" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::tgba_powerset((std::shared_ptr< spot::twa_graph const > const &)*arg1,*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_powerset__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::power_map *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_powerset" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__power_map,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_powerset" "', argument " "2"" of type '" "spot::power_map &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_powerset" "', argument " "2"" of type '" "spot::power_map &""'"); 
  }
  arg2 = reinterpret_cast< spot::power_map * >(argp2);
  {
    try {
      result = spot::tgba_powerset((std::shared_ptr< spot::twa_graph const > const &)*arg1,*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_powerset__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::output_aborter *arg2 = (spot::output_aborter *) 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = (std::vector< unsigned int,std::allocator< unsigned int > > *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_powerset" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_powerset" "', argument " "2"" of type '" "spot::output_aborter const *""'"); 
  }
  arg2 = reinterpret_cast< spot::output_aborter * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tgba_powerset" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > *""'"); 
  }
  arg3 = reinterpret_cast< std::vector< unsigned int,std::allocator< unsigned int > > * >(argp3);
  {
    try {
      result = spot::tgba_powerset((std::shared_ptr< spot::twa_graph const > const &)*arg1,(spot::output_aborter const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_powerset__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::output_aborter *arg2 = (spot::output_aborter *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_powerset" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_powerset" "', argument " "2"" of type '" "spot::output_aborter const *""'"); 
  }
  arg2 = reinterpret_cast< spot::output_aborter * >(argp2);
  {
    try {
      result = spot::tgba_powerset((std::shared_ptr< spot::twa_graph const > const &)*arg1,(spot::output_aborter const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_powerset__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_powerset" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::tgba_powerset((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_powerset(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "tgba_powerset", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_tgba_powerset__SWIG_6(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__output_aborter, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_tgba_powerset__SWIG_5(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_tgba_powerset__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__power_map, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    {
      {
        int res = SWIG_AsVal_bool(argv[2], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_4;
    return _wrap_tgba_powerset__SWIG_2(self, argc, argv);
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_tgba_powerset__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_tgba_powerset__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_tgba_powerset__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'tgba_powerset'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::tgba_powerset(spot::const_twa_graph_ptr const &,spot::power_map &,bool,spot::output_aborter const *,std::vector< unsigned int,std::allocator< unsigned int > > *)\n"
    "    spot::tgba_powerset(spot::const_twa_graph_ptr const &,spot::power_map &,bool,spot::output_aborter const *)\n"
    "    spot::tgba_powerset(spot::const_twa_graph_ptr const &,spot::power_map &,bool)\n"
    "    spot::tgba_powerset(spot::const_twa_graph_ptr const &,spot::power_map &)\n"
    "    spot::tgba_powerset(spot::const_twa_graph_ptr const &,spot::output_aborter const *,std::vector< unsigned int,std::allocator< unsigned int > > *)\n"
    "    spot::tgba_powerset(spot::const_twa_graph_ptr const &,spot::output_aborter const *)\n"
    "    spot::tgba_powerset(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_tba_determinize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tba_determinize" "', 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 '" "tba_determinize" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = spot::tba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tba_determinize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tba_determinize" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = spot::tba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tba_determinize__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tba_determinize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::tba_determinize((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tba_determinize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "tba_determinize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_tba_determinize__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_tba_determinize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_tba_determinize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'tba_determinize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::tba_determinize(spot::const_twa_graph_ptr const &,unsigned int,unsigned int)\n"
    "    spot::tba_determinize(spot::const_twa_graph_ptr const &,unsigned int)\n"
    "    spot::tba_determinize(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_tba_determinize_check__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  spot::formula arg4 ;
  spot::const_twa_graph_ptr arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tba_determinize_check" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tba_determinize_check" "', 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 '" "tba_determinize_check" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[3], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tba_determinize_check" "', argument " "4"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg4 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg4 is fine.
  }
  {
    int newmem = 0;
    res5 = SWIG_ConvertPtrAndOwn(swig_obj[4], &argp5, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "tba_determinize_check" "', argument " "5"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp5) arg5 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp5));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp5);
  }
  {
    try {
      result = spot::tba_determinize_check((std::shared_ptr< spot::twa_graph > const &)*arg1,arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tba_determinize_check__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  spot::formula arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tba_determinize_check" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tba_determinize_check" "', 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 '" "tba_determinize_check" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[3], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tba_determinize_check" "', argument " "4"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg4 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg4 is fine.
  }
  {
    try {
      result = spot::tba_determinize_check((std::shared_ptr< spot::twa_graph > const &)*arg1,arg2,arg3,SWIG_STD_MOVE(arg4));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tba_determinize_check__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tba_determinize_check" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tba_determinize_check" "', 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 '" "tba_determinize_check" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = spot::tba_determinize_check((std::shared_ptr< spot::twa_graph > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tba_determinize_check__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tba_determinize_check" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tba_determinize_check" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = spot::tba_determinize_check((std::shared_ptr< spot::twa_graph > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tba_determinize_check__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tba_determinize_check" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::tba_determinize_check((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tba_determinize_check(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "tba_determinize_check", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_tba_determinize_check__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_tba_determinize_check__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_tba_determinize_check__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_tba_determinize_check__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_tba_determinize_check__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'tba_determinize_check'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::tba_determinize_check(spot::twa_graph_ptr const &,unsigned int,unsigned int,spot::formula,spot::const_twa_graph_ptr)\n"
    "    spot::tba_determinize_check(spot::twa_graph_ptr const &,unsigned int,unsigned int,spot::formula)\n"
    "    spot::tba_determinize_check(spot::twa_graph_ptr const &,unsigned int,unsigned int)\n"
    "    spot::tba_determinize_check(spot::twa_graph_ptr const &,unsigned int)\n"
    "    spot::tba_determinize_check(spot::twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_product__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  spot::output_aborter *arg3 = (spot::output_aborter *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "product" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "product" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "product" "', argument " "3"" of type '" "spot::output_aborter const *""'"); 
  }
  arg3 = reinterpret_cast< spot::output_aborter * >(argp3);
  {
    try {
      result = spot::product((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2,(spot::output_aborter const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_product__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "product" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "product" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::product((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_product__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  spot::output_aborter *arg5 = (spot::output_aborter *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "product" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "product" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "product" "', 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 '" "product" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "product" "', argument " "5"" of type '" "spot::output_aborter const *""'"); 
  }
  arg5 = reinterpret_cast< spot::output_aborter * >(argp5);
  {
    try {
      result = spot::product((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2,arg3,arg4,(spot::output_aborter const *)arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_product__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "product" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "product" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "product" "', 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 '" "product" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = spot::product((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_product(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "product", 0, 5, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_product__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_product__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_product__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_product__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'product'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::product(spot::const_twa_graph_ptr const &,spot::const_twa_graph_ptr const &,spot::output_aborter const *)\n"
    "    spot::product(spot::const_twa_graph_ptr const &,spot::const_twa_graph_ptr const &)\n"
    "    spot::product(spot::const_twa_graph_ptr const &,spot::const_twa_graph_ptr const &,unsigned int,unsigned int,spot::output_aborter const *)\n"
    "    spot::product(spot::const_twa_graph_ptr const &,spot::const_twa_graph_ptr const &,unsigned int,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_product_or__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "product_or" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "product_or" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::product_or((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_product_or__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "product_or" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "product_or" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "product_or" "', 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 '" "product_or" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = spot::product_or((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_product_or(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "product_or", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_product_or__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_product_or__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'product_or'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::product_or(spot::const_twa_graph_ptr const &,spot::const_twa_graph_ptr const &)\n"
    "    spot::product_or(spot::const_twa_graph_ptr const &,spot::const_twa_graph_ptr const &,unsigned int,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_product_xor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  spot::twa_graph_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "product_xor", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "product_xor" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "product_xor" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::product_xor((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_product_xnor(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  spot::twa_graph_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "product_xnor", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "product_xnor" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "product_xnor" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::product_xnor((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_product_susp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  spot::twa_graph_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "product_susp", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "product_susp" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "product_susp" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::product_susp((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_product_or_susp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  spot::twa_graph_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "product_or_susp", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "product_or_susp" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "product_or_susp" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::product_or_susp((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_split_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "split_edges" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::split_edges((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sum" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sum" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::sum((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sum" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sum" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sum" "', 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 '" "sum" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = spot::sum((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "sum", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_sum__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_sum__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'sum'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::sum(spot::const_twa_graph_ptr const &,spot::const_twa_graph_ptr const &)\n"
    "    spot::sum(spot::const_twa_graph_ptr const &,spot::const_twa_graph_ptr const &,unsigned int,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_sum_and__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sum_and" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sum_and" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::sum_and((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum_and__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::const_twa_graph_ptr *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_graph_ptr tempshared2 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sum_and" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sum_and" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sum_and" "', 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 '" "sum_and" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = spot::sum_and((std::shared_ptr< spot::twa_graph const > const &)*arg1,(std::shared_ptr< spot::twa_graph const > const &)*arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sum_and(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "sum_and", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_sum_and__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_sum_and__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'sum_and'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::sum_and(spot::const_twa_graph_ptr const &,spot::const_twa_graph_ptr const &)\n"
    "    spot::sum_and(spot::const_twa_graph_ptr const &,spot::const_twa_graph_ptr const &,unsigned int,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_sl(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sl" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::sl(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sl2_inplace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sl2_inplace" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::sl2_inplace(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sl2(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sl2" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::sl2(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_closure_inplace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "closure_inplace" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::closure_inplace(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_closure(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "closure" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::closure(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_stutter_invariant__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  spot::twa_graph_ptr arg2 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_stutter_invariant" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_stutter_invariant" "', argument " "2"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::is_stutter_invariant(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_stutter_invariant__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "is_stutter_invariant" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    try {
      result = (bool)spot::is_stutter_invariant(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_stutter_invariant__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  bool result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_stutter_invariant" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_stutter_invariant" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "is_stutter_invariant" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (bool)spot::is_stutter_invariant(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_stutter_invariant__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_stutter_invariant" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_stutter_invariant" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::is_stutter_invariant(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_stutter_invariant__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_stutter_invariant" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = (bool)spot::is_stutter_invariant(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_is_stutter_invariant(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "is_stutter_invariant", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_is_stutter_invariant__SWIG_4(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_is_stutter_invariant__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_is_stutter_invariant__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_is_stutter_invariant__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_is_stutter_invariant__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'is_stutter_invariant'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::is_stutter_invariant(spot::formula,spot::twa_graph_ptr)\n"
    "    spot::is_stutter_invariant(spot::formula)\n"
    "    spot::is_stutter_invariant(spot::twa_graph_ptr,spot::const_twa_graph_ptr,int)\n"
    "    spot::is_stutter_invariant(spot::twa_graph_ptr,spot::const_twa_graph_ptr)\n"
    "    spot::is_stutter_invariant(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_check_stutter_invariance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::formula arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::trival result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "check_stutter_invariance" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "check_stutter_invariance" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "check_stutter_invariance" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "check_stutter_invariance" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::check_stutter_invariance(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_stutter_invariance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::formula arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::trival result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "check_stutter_invariance" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "check_stutter_invariance" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "check_stutter_invariance" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::check_stutter_invariance(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_stutter_invariance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::formula arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "check_stutter_invariance" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "check_stutter_invariance" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = spot::check_stutter_invariance(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_stutter_invariance__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::trival result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "check_stutter_invariance" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::check_stutter_invariance(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::trival(result)), SWIGTYPE_p_spot__trival, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_check_stutter_invariance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "check_stutter_invariance", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_check_stutter_invariance__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_check_stutter_invariance__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_check_stutter_invariance__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_check_stutter_invariance__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'check_stutter_invariance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::check_stutter_invariance(spot::twa_graph_ptr,spot::formula,bool,bool)\n"
    "    spot::check_stutter_invariance(spot::twa_graph_ptr,spot::formula,bool)\n"
    "    spot::check_stutter_invariance(spot::twa_graph_ptr,spot::formula)\n"
    "    spot::check_stutter_invariance(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_stutter_invariant_states__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< bool,std::allocator< bool > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stutter_invariant_states" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "stutter_invariant_states" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = spot::stutter_invariant_states(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stutter_invariant_states__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  std::vector< bool,std::allocator< bool > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stutter_invariant_states" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::stutter_invariant_states(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stutter_invariant_states__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::formula arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  std::vector< bool,std::allocator< bool > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stutter_invariant_states" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "stutter_invariant_states" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = spot::stutter_invariant_states(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stutter_invariant_states(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "stutter_invariant_states", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_stutter_invariant_states__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_stutter_invariant_states__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_stutter_invariant_states__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'stutter_invariant_states'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::stutter_invariant_states(spot::const_twa_graph_ptr,spot::const_twa_graph_ptr)\n"
    "    spot::stutter_invariant_states(spot::const_twa_graph_ptr)\n"
    "    spot::stutter_invariant_states(spot::const_twa_graph_ptr,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_highlight_stutter_invariant_states__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::formula arg2 ;
  unsigned int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_stutter_invariant_states" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "highlight_stutter_invariant_states" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "highlight_stutter_invariant_states" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      spot::highlight_stutter_invariant_states(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_stutter_invariant_states__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::formula arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_stutter_invariant_states" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "highlight_stutter_invariant_states" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      spot::highlight_stutter_invariant_states(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_stutter_invariant_states__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  unsigned int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_stutter_invariant_states" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "highlight_stutter_invariant_states" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "highlight_stutter_invariant_states" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      spot::highlight_stutter_invariant_states(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_stutter_invariant_states__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_stutter_invariant_states" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "highlight_stutter_invariant_states" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      spot::highlight_stutter_invariant_states(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_stutter_invariant_states__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "highlight_stutter_invariant_states" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      spot::highlight_stutter_invariant_states(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_highlight_stutter_invariant_states(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "highlight_stutter_invariant_states", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_highlight_stutter_invariant_states__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_highlight_stutter_invariant_states__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_highlight_stutter_invariant_states__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    PyObject *retobj = _wrap_highlight_stutter_invariant_states__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_4:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_highlight_stutter_invariant_states__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'highlight_stutter_invariant_states'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::highlight_stutter_invariant_states(spot::twa_graph_ptr,spot::formula,unsigned int)\n"
    "    spot::highlight_stutter_invariant_states(spot::twa_graph_ptr,spot::formula)\n"
    "    spot::highlight_stutter_invariant_states(spot::twa_graph_ptr,spot::const_twa_graph_ptr,unsigned int)\n"
    "    spot::highlight_stutter_invariant_states(spot::twa_graph_ptr,spot::const_twa_graph_ptr)\n"
    "    spot::highlight_stutter_invariant_states(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_stutter_invariant_letters__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::vector< bdd,std::allocator< bdd > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stutter_invariant_letters" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "stutter_invariant_letters" "', argument " "2"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = spot::stutter_invariant_letters(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< bdd,std::allocator< bdd > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stutter_invariant_letters__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  std::vector< bdd,std::allocator< bdd > > result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stutter_invariant_letters" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::stutter_invariant_letters(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< bdd,std::allocator< bdd > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stutter_invariant_letters__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::formula arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  std::vector< bdd,std::allocator< bdd > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stutter_invariant_letters" "', argument " "1"" of type '" "spot::const_twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "stutter_invariant_letters" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = spot::stutter_invariant_letters(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< bdd,std::allocator< bdd > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stutter_invariant_letters(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "stutter_invariant_letters", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_stutter_invariant_letters__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_stutter_invariant_letters__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_stutter_invariant_letters__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'stutter_invariant_letters'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::stutter_invariant_letters(spot::const_twa_graph_ptr,spot::const_twa_graph_ptr)\n"
    "    spot::stutter_invariant_letters(spot::const_twa_graph_ptr)\n"
    "    spot::stutter_invariant_letters(spot::const_twa_graph_ptr,spot::formula)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_is_stutter_invariant_forward_closed(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  std::vector< bool,std::allocator< bool > > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  int result;
  
  if (!SWIG_Python_UnpackTuple(args, "is_stutter_invariant_forward_closed", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "is_stutter_invariant_forward_closed" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "is_stutter_invariant_forward_closed" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "is_stutter_invariant_forward_closed" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (int)spot::is_stutter_invariant_forward_closed(SWIG_STD_MOVE(arg1),(std::vector< bool,std::allocator< bool > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_stutter_invariant_forward_closed_inplace(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  std::vector< bool,std::allocator< bool > > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  std::vector< bool,std::allocator< bool > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "make_stutter_invariant_forward_closed_inplace", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_stutter_invariant_forward_closed_inplace" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "make_stutter_invariant_forward_closed_inplace" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "make_stutter_invariant_forward_closed_inplace" "', argument " "2"" of type '" "std::vector< bool,std::allocator< bool > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = spot::make_stutter_invariant_forward_closed_inplace(SWIG_STD_MOVE(arg1),(std::vector< bool,std::allocator< bool > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector<bool,std::allocator< bool > > >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_split_2step__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bdd *arg2 = 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "split_2step" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "split_2step" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "split_2step" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "split_2step" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::split_2step((std::shared_ptr< spot::twa_graph const > const &)*arg1,(bdd const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_split_2step__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bdd *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "split_2step" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "split_2step" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "split_2step" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  {
    try {
      result = spot::split_2step((std::shared_ptr< spot::twa_graph const > const &)*arg1,(bdd const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_split_2step__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "split_2step" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "split_2step" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::split_2step((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_split_2step__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "split_2step" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::split_2step((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_split_2step(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "split_2step", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_split_2step__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_bdd, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_split_2step__SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_split_2step__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_split_2step__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'split_2step'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::split_2step(spot::const_twa_graph_ptr const &,bdd const &,bool)\n"
    "    spot::split_2step(spot::const_twa_graph_ptr const &,bdd const &)\n"
    "    spot::split_2step(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::split_2step(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_unsplit_2step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unsplit_2step" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::unsplit_2step((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_synthesis_info(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_synthesis_info", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::synthesis_info *)new spot::synthesis_info();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__synthesis_info, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_force_sbacc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "synthesis_info_force_sbacc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_force_sbacc_set" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "synthesis_info_force_sbacc_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->force_sbacc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_force_sbacc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_force_sbacc_get" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  result = (bool) ((arg1)->force_sbacc);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_s_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  spot::synthesis_info::algo arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "synthesis_info_s_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_s_set" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "synthesis_info_s_set" "', argument " "2"" of type '" "spot::synthesis_info::algo""'");
  } 
  arg2 = static_cast< spot::synthesis_info::algo >(val2);
  if (arg1) (arg1)->s = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_s_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::synthesis_info::algo result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_s_get" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  result = (spot::synthesis_info::algo) ((arg1)->s);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_minimize_lvl_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "synthesis_info_minimize_lvl_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_minimize_lvl_set" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "synthesis_info_minimize_lvl_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->minimize_lvl = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_minimize_lvl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_minimize_lvl_get" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  result = (int) ((arg1)->minimize_lvl);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_bv_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  std::optional< spot::synthesis_info::bench_var > *arg2 = (std::optional< spot::synthesis_info::bench_var > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "synthesis_info_bv_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_bv_set" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__optionalT_spot__synthesis_info__bench_var_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "synthesis_info_bv_set" "', argument " "2"" of type '" "std::optional< spot::synthesis_info::bench_var > *""'"); 
  }
  arg2 = reinterpret_cast< std::optional< spot::synthesis_info::bench_var > * >(argp2);
  if (arg1) (arg1)->bv = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_bv_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::optional< spot::synthesis_info::bench_var > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_bv_get" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  result = (std::optional< spot::synthesis_info::bench_var > *)& ((arg1)->bv);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__optionalT_spot__synthesis_info__bench_var_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_verbose_stream_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  std::ostream *arg2 = (std::ostream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "synthesis_info_verbose_stream_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_verbose_stream_set" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__ostream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "synthesis_info_verbose_stream_set" "', argument " "2"" of type '" "std::ostream *""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  if (arg1) (arg1)->verbose_stream = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_verbose_stream_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::ostream *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_verbose_stream_get" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  result = (std::ostream *) ((arg1)->verbose_stream);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_opt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  spot::option_map *arg2 = (spot::option_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "synthesis_info_opt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_opt_set" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "synthesis_info_opt_set" "', argument " "2"" of type '" "spot::option_map *""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  if (arg1) (arg1)->opt = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_opt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::option_map *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_opt_get" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  result = (spot::option_map *)& ((arg1)->opt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__option_map, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_dict_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "synthesis_info_dict_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_dict_set" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "synthesis_info_dict_set" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  if (arg1) (arg1)->dict = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_synthesis_info_dict_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::bdd_dict_ptr *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "synthesis_info_dict_get" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  result = (spot::bdd_dict_ptr *) & ((arg1)->dict);
  {
    std::shared_ptr<  spot::bdd_dict > *smartresult = *result ? new std::shared_ptr<  spot::bdd_dict >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_synthesis_info(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::synthesis_info *arg1 = (spot::synthesis_info *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__synthesis_info, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_synthesis_info" "', argument " "1"" of type '" "spot::synthesis_info *""'"); 
  }
  arg1 = reinterpret_cast< spot::synthesis_info * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *synthesis_info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__synthesis_info, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *synthesis_info_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap___lshift____SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::synthesis_info::algo arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "__lshift__" "', argument " "2"" of type '" "spot::synthesis_info::algo""'");
  } 
  arg2 = static_cast< spot::synthesis_info::algo >(val2);
  {
    try {
      result = (std::ostream *) &spot::operator <<(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lshift____SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::synthesis_info *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__synthesis_info,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "spot::synthesis_info const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "spot::synthesis_info const &""'"); 
  }
  arg2 = reinterpret_cast< spot::synthesis_info * >(argp2);
  {
    try {
      result = (std::ostream *) &spot::operator <<(*arg1,(spot::synthesis_info const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__trival, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap___lshift____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__formula, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap___lshift____SWIG_1(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__acc_cond, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap___lshift____SWIG_2(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__synthesis_info, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    return _wrap___lshift____SWIG_4(self, argc, argv);
  }
check_4:
  
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    return _wrap___lshift____SWIG_3(self, argc, argv);
  }
check_5:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__trival, SWIG_POINTER_NO_NULL | SWIG_POINTER_IMPLICIT_CONV);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_6;
    return _wrap___lshift____SWIG_0(self, argc, argv);
  }
check_6:
  
  if (argc == 2) {
    PyObject *retobj = _wrap___lshift____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_ltl_to_game__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  spot::synthesis_info *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ltl_to_game" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ltl_to_game" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_game" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ltl_to_game" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__synthesis_info,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ltl_to_game" "', argument " "3"" of type '" "spot::synthesis_info &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ltl_to_game" "', argument " "3"" of type '" "spot::synthesis_info &""'"); 
  }
  arg3 = reinterpret_cast< spot::synthesis_info * >(argp3);
  {
    try {
      result = spot::ltl_to_game((spot::formula const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2,*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  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_ltl_to_game__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__formula,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ltl_to_game" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ltl_to_game" "', argument " "1"" of type '" "spot::formula const &""'"); 
  }
  arg1 = reinterpret_cast< spot::formula * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_game" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ltl_to_game" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = spot::ltl_to_game((spot::formula const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  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_ltl_to_game__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  spot::synthesis_info *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ltl_to_game" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ltl_to_game" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_game" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ltl_to_game" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__synthesis_info,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ltl_to_game" "', argument " "3"" of type '" "spot::synthesis_info &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ltl_to_game" "', argument " "3"" of type '" "spot::synthesis_info &""'"); 
  }
  arg3 = reinterpret_cast< spot::synthesis_info * >(argp3);
  {
    try {
      result = spot::ltl_to_game((std::string const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2,*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  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_ltl_to_game__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ltl_to_game" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ltl_to_game" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ltl_to_game" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ltl_to_game" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = spot::ltl_to_game((std::string const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  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_ltl_to_game(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ltl_to_game", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__formula, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_ltl_to_game__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    PyObject *retobj = _wrap_ltl_to_game__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_ltl_to_game__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__formula, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    PyObject *retobj = _wrap_ltl_to_game__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_ltl_to_game__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_ltl_to_game__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ltl_to_game'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::ltl_to_game(spot::formula const &,std::vector< std::string,std::allocator< std::string > > const &,spot::synthesis_info &)\n"
    "    spot::ltl_to_game(spot::formula const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    spot::ltl_to_game(std::string const &,std::vector< std::string,std::allocator< std::string > > const &,spot::synthesis_info &)\n"
    "    spot::ltl_to_game(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_solved_game_to_mealy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::synthesis_info *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solved_game_to_mealy" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__synthesis_info,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "solved_game_to_mealy" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "solved_game_to_mealy" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  arg2 = reinterpret_cast< spot::synthesis_info * >(argp2);
  {
    try {
      result = spot::solved_game_to_mealy(SWIG_STD_MOVE(arg1),*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_solved_game_to_mealy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solved_game_to_mealy" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::solved_game_to_mealy(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_solved_game_to_mealy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "solved_game_to_mealy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_solved_game_to_mealy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_solved_game_to_mealy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'solved_game_to_mealy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::solved_game_to_mealy(spot::twa_graph_ptr,spot::synthesis_info &)\n"
    "    spot::solved_game_to_mealy(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_solved_game_to_separated_mealy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::synthesis_info *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solved_game_to_separated_mealy" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__synthesis_info,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "solved_game_to_separated_mealy" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "solved_game_to_separated_mealy" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  arg2 = reinterpret_cast< spot::synthesis_info * >(argp2);
  {
    try {
      result = spot::solved_game_to_separated_mealy(SWIG_STD_MOVE(arg1),*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_solved_game_to_separated_mealy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solved_game_to_separated_mealy" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::solved_game_to_separated_mealy(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_solved_game_to_separated_mealy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "solved_game_to_separated_mealy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_solved_game_to_separated_mealy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_solved_game_to_separated_mealy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'solved_game_to_separated_mealy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::solved_game_to_separated_mealy(spot::twa_graph_ptr,spot::synthesis_info &)\n"
    "    spot::solved_game_to_separated_mealy(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_solved_game_to_split_mealy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::synthesis_info *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solved_game_to_split_mealy" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__synthesis_info,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "solved_game_to_split_mealy" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "solved_game_to_split_mealy" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  arg2 = reinterpret_cast< spot::synthesis_info * >(argp2);
  {
    try {
      result = spot::solved_game_to_split_mealy(SWIG_STD_MOVE(arg1),*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_solved_game_to_split_mealy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solved_game_to_split_mealy" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = spot::solved_game_to_split_mealy(SWIG_STD_MOVE(arg1));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_solved_game_to_split_mealy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "solved_game_to_split_mealy", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_solved_game_to_split_mealy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_solved_game_to_split_mealy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'solved_game_to_split_mealy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::solved_game_to_split_mealy(spot::twa_graph_ptr,spot::synthesis_info &)\n"
    "    spot::solved_game_to_split_mealy(spot::twa_graph_ptr)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_mealy_like_success_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::mealy_like *arg1 = (spot::mealy_like *) 0 ;
  spot::mealy_like::realizability_code arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "mealy_like_success_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__mealy_like, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_like_success_set" "', argument " "1"" of type '" "spot::mealy_like *""'"); 
  }
  arg1 = reinterpret_cast< spot::mealy_like * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mealy_like_success_set" "', argument " "2"" of type '" "spot::mealy_like::realizability_code""'");
  } 
  arg2 = static_cast< spot::mealy_like::realizability_code >(val2);
  if (arg1) (arg1)->success = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_like_success_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::mealy_like *arg1 = (spot::mealy_like *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::mealy_like::realizability_code result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__mealy_like, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_like_success_get" "', argument " "1"" of type '" "spot::mealy_like *""'"); 
  }
  arg1 = reinterpret_cast< spot::mealy_like * >(argp1);
  result = (spot::mealy_like::realizability_code) ((arg1)->success);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_like_mealy_like_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::mealy_like *arg1 = (spot::mealy_like *) 0 ;
  spot::twa_graph_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "mealy_like_mealy_like_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__mealy_like, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_like_mealy_like_set" "', argument " "1"" of type '" "spot::mealy_like *""'"); 
  }
  arg1 = reinterpret_cast< spot::mealy_like * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_like_mealy_like_set" "', argument " "2"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  if (arg1) (arg1)->mealy_like = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_like_mealy_like_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::mealy_like *arg1 = (spot::mealy_like *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__mealy_like, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_like_mealy_like_get" "', argument " "1"" of type '" "spot::mealy_like *""'"); 
  }
  arg1 = reinterpret_cast< spot::mealy_like * >(argp1);
  result = (spot::twa_graph_ptr *) & ((arg1)->mealy_like);
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = *result ? new std::shared_ptr<  spot::twa_graph >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_like_glob_cond_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::mealy_like *arg1 = (spot::mealy_like *) 0 ;
  bdd *arg2 = (bdd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "mealy_like_glob_cond_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__mealy_like, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_like_glob_cond_set" "', argument " "1"" of type '" "spot::mealy_like *""'"); 
  }
  arg1 = reinterpret_cast< spot::mealy_like * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_bdd, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mealy_like_glob_cond_set" "', argument " "2"" of type '" "bdd *""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  if (arg1) (arg1)->glob_cond = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mealy_like_glob_cond_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::mealy_like *arg1 = (spot::mealy_like *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bdd *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__mealy_like, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mealy_like_glob_cond_get" "', argument " "1"" of type '" "spot::mealy_like *""'"); 
  }
  arg1 = reinterpret_cast< spot::mealy_like * >(argp1);
  result = (bdd *)& ((arg1)->glob_cond);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bdd, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_mealy_like(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::mealy_like *arg1 = (spot::mealy_like *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__mealy_like, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mealy_like" "', argument " "1"" of type '" "spot::mealy_like *""'"); 
  }
  arg1 = reinterpret_cast< spot::mealy_like * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *mealy_like_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__mealy_like, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_split_independant_formulas__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< std::pair< std::vector< spot::formula,std::allocator< spot::formula > >,std::vector< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > >,std::allocator< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > > > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "split_independant_formulas" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "split_independant_formulas" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "split_independant_formulas" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = spot::split_independant_formulas(SWIG_STD_MOVE(arg1),(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::pair< std::vector< spot::formula,std::allocator< spot::formula > >,std::vector< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > >,std::allocator< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > > > >(result)), SWIGTYPE_p_std__pairT_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t_std__vectorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_std__allocatorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_split_independant_formulas__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< std::pair< std::vector< spot::formula,std::allocator< spot::formula > >,std::vector< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > >,std::allocator< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > > > > > result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "split_independant_formulas" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "split_independant_formulas" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "split_independant_formulas" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "split_independant_formulas" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = spot::split_independant_formulas((std::string const &)*arg1,(std::vector< std::string,std::allocator< std::string > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::pair< std::vector< spot::formula,std::allocator< spot::formula > >,std::vector< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > >,std::allocator< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > > > >(result)), SWIGTYPE_p_std__pairT_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t_std__vectorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_std__allocatorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_t_t_t, SWIG_POINTER_OWN |  0 );
  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_split_independant_formulas(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "split_independant_formulas", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    PyObject *retobj = _wrap_split_independant_formulas__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_split_independant_formulas__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'split_independant_formulas'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::split_independant_formulas(spot::formula,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    spot::split_independant_formulas(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_try_create_direct_strategy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  spot::synthesis_info *arg3 = 0 ;
  bool arg4 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::mealy_like result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "try_create_direct_strategy" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "try_create_direct_strategy" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "try_create_direct_strategy" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__synthesis_info,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "try_create_direct_strategy" "', argument " "3"" of type '" "spot::synthesis_info &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "try_create_direct_strategy" "', argument " "3"" of type '" "spot::synthesis_info &""'"); 
  }
  arg3 = reinterpret_cast< spot::synthesis_info * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "try_create_direct_strategy" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::try_create_direct_strategy(SWIG_STD_MOVE(arg1),(std::vector< std::string,std::allocator< std::string > > const &)*arg2,*arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::mealy_like(result)), SWIGTYPE_p_spot__mealy_like, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_try_create_direct_strategy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::formula arg1 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  spot::synthesis_info *arg3 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::mealy_like result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[0], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "try_create_direct_strategy" "', argument " "1"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg1 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg1 is fine.
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "try_create_direct_strategy" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "try_create_direct_strategy" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__synthesis_info,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "try_create_direct_strategy" "', argument " "3"" of type '" "spot::synthesis_info &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "try_create_direct_strategy" "', argument " "3"" of type '" "spot::synthesis_info &""'"); 
  }
  arg3 = reinterpret_cast< spot::synthesis_info * >(argp3);
  {
    try {
      result = spot::try_create_direct_strategy(SWIG_STD_MOVE(arg1),(std::vector< std::string,std::allocator< std::string > > const &)*arg2,*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::mealy_like(result)), SWIGTYPE_p_spot__mealy_like, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_try_create_direct_strategy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "try_create_direct_strategy", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_try_create_direct_strategy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_try_create_direct_strategy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'try_create_direct_strategy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::try_create_direct_strategy(spot::formula,std::vector< std::string,std::allocator< std::string > > const &,spot::synthesis_info &,bool)\n"
    "    spot::try_create_direct_strategy(spot::formula,std::vector< std::string,std::allocator< std::string > > const &,spot::synthesis_info &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_solve_game__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  spot::synthesis_info *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "solve_game" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__synthesis_info,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "solve_game" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "solve_game" "', argument " "2"" of type '" "spot::synthesis_info &""'"); 
  }
  arg2 = reinterpret_cast< spot::synthesis_info * >(argp2);
  {
    try {
      result = (bool)spot::solve_game(SWIG_STD_MOVE(arg1),*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_solve_game(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "solve_game", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_solve_game__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_solve_game__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'solve_game'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::solve_game(spot::twa_graph_ptr const &)\n"
    "    spot::solve_game(spot::twa_graph_ptr,spot::synthesis_info &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_game_relabeling_map_env_map_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::game_relabeling_map *arg1 = (spot::game_relabeling_map *) 0 ;
  spot::relabeling_map *arg2 = (spot::relabeling_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "game_relabeling_map_env_map_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__game_relabeling_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "game_relabeling_map_env_map_set" "', argument " "1"" of type '" "spot::game_relabeling_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::game_relabeling_map * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "game_relabeling_map_env_map_set" "', argument " "2"" of type '" "spot::relabeling_map *""'"); 
  }
  arg2 = reinterpret_cast< spot::relabeling_map * >(argp2);
  if (arg1) (arg1)->env_map = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_game_relabeling_map_env_map_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::game_relabeling_map *arg1 = (spot::game_relabeling_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::relabeling_map *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__game_relabeling_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "game_relabeling_map_env_map_get" "', argument " "1"" of type '" "spot::game_relabeling_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::game_relabeling_map * >(argp1);
  result = (spot::relabeling_map *)& ((arg1)->env_map);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_game_relabeling_map_player_map_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::game_relabeling_map *arg1 = (spot::game_relabeling_map *) 0 ;
  spot::relabeling_map *arg2 = (spot::relabeling_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "game_relabeling_map_player_map_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__game_relabeling_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "game_relabeling_map_player_map_set" "', argument " "1"" of type '" "spot::game_relabeling_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::game_relabeling_map * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "game_relabeling_map_player_map_set" "', argument " "2"" of type '" "spot::relabeling_map *""'"); 
  }
  arg2 = reinterpret_cast< spot::relabeling_map * >(argp2);
  if (arg1) (arg1)->player_map = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_game_relabeling_map_player_map_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::game_relabeling_map *arg1 = (spot::game_relabeling_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::relabeling_map *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__game_relabeling_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "game_relabeling_map_player_map_get" "', argument " "1"" of type '" "spot::game_relabeling_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::game_relabeling_map * >(argp1);
  result = (spot::relabeling_map *)& ((arg1)->player_map);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_game_relabeling_map(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::game_relabeling_map *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_game_relabeling_map", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::game_relabeling_map *)new spot::game_relabeling_map();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__game_relabeling_map, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_game_relabeling_map(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::game_relabeling_map *arg1 = (spot::game_relabeling_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__game_relabeling_map, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_game_relabeling_map" "', argument " "1"" of type '" "spot::game_relabeling_map *""'"); 
  }
  arg1 = reinterpret_cast< spot::game_relabeling_map * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *game_relabeling_map_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__game_relabeling_map, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *game_relabeling_map_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_partitioned_game_relabel_here__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  unsigned int arg6 ;
  unsigned int arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  spot::game_relabeling_map result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_game_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "partitioned_game_relabel_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "partitioned_game_relabel_here" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "partitioned_game_relabel_here" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "partitioned_game_relabel_here" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "partitioned_game_relabel_here" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "partitioned_game_relabel_here" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  {
    try {
      result = spot::partitioned_game_relabel_here(*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::game_relabeling_map(result)), SWIGTYPE_p_spot__game_relabeling_map, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_game_relabel_here__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  unsigned int arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  spot::game_relabeling_map result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_game_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "partitioned_game_relabel_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "partitioned_game_relabel_here" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "partitioned_game_relabel_here" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "partitioned_game_relabel_here" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "partitioned_game_relabel_here" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  {
    try {
      result = spot::partitioned_game_relabel_here(*arg1,arg2,arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::game_relabeling_map(result)), SWIGTYPE_p_spot__game_relabeling_map, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_game_relabel_here__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::game_relabeling_map result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_game_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "partitioned_game_relabel_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "partitioned_game_relabel_here" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "partitioned_game_relabel_here" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "partitioned_game_relabel_here" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = spot::partitioned_game_relabel_here(*arg1,arg2,arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::game_relabeling_map(result)), SWIGTYPE_p_spot__game_relabeling_map, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_game_relabel_here__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::game_relabeling_map result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_game_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "partitioned_game_relabel_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "partitioned_game_relabel_here" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "partitioned_game_relabel_here" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::partitioned_game_relabel_here(*arg1,arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::game_relabeling_map(result)), SWIGTYPE_p_spot__game_relabeling_map, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_game_relabel_here__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::game_relabeling_map result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_game_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "partitioned_game_relabel_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "partitioned_game_relabel_here" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::partitioned_game_relabel_here(*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::game_relabeling_map(result)), SWIGTYPE_p_spot__game_relabeling_map, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_game_relabel_here(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "partitioned_game_relabel_here", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_partitioned_game_relabel_here__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_partitioned_game_relabel_here__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_partitioned_game_relabel_here__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_partitioned_game_relabel_here__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_partitioned_game_relabel_here__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'partitioned_game_relabel_here'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::partitioned_game_relabel_here(spot::twa_graph_ptr &,bool,bool,bool,bool,unsigned int,unsigned int)\n"
    "    spot::partitioned_game_relabel_here(spot::twa_graph_ptr &,bool,bool,bool,bool,unsigned int)\n"
    "    spot::partitioned_game_relabel_here(spot::twa_graph_ptr &,bool,bool,bool,bool)\n"
    "    spot::partitioned_game_relabel_here(spot::twa_graph_ptr &,bool,bool,bool)\n"
    "    spot::partitioned_game_relabel_here(spot::twa_graph_ptr &,bool,bool)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_relabel_game_here(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  spot::game_relabeling_map *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "relabel_game_here", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabel_game_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__game_relabeling_map,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabel_game_here" "', argument " "2"" of type '" "spot::game_relabeling_map &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "relabel_game_here" "', argument " "2"" of type '" "spot::game_relabeling_map &""'"); 
  }
  arg2 = reinterpret_cast< spot::game_relabeling_map * >(argp2);
  {
    try {
      spot::relabel_game_here(*arg1,*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_translator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  spot::option_map *arg2 = (spot::option_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::translator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_translator" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_translator" "', argument " "2"" of type '" "spot::option_map const *""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  {
    try {
      result = (spot::translator *)new spot::translator(arg1,(spot::option_map const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__translator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_translator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::tl_simplifier *arg1 = (spot::tl_simplifier *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::translator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__tl_simplifier, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_translator" "', argument " "1"" of type '" "spot::tl_simplifier *""'"); 
  }
  arg1 = reinterpret_cast< spot::tl_simplifier * >(argp1);
  {
    try {
      result = (spot::translator *)new spot::translator(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__translator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_translator__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  spot::option_map *arg2 = (spot::option_map *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::translator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_translator" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_translator" "', argument " "2"" of type '" "spot::option_map const *""'"); 
  }
  arg2 = reinterpret_cast< spot::option_map * >(argp2);
  {
    try {
      result = (spot::translator *)new spot::translator((spot::bdd_dict_ptr const &)*arg1,(spot::option_map const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__translator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_translator__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  spot::translator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_translator" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::translator *)new spot::translator((spot::bdd_dict_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__translator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_translator__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::option_map *arg1 = (spot::option_map *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::translator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__option_map, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_translator" "', argument " "1"" of type '" "spot::option_map const *""'"); 
  }
  arg1 = reinterpret_cast< spot::option_map * >(argp1);
  {
    try {
      result = (spot::translator *)new spot::translator((spot::option_map const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__translator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_translator__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::translator *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::translator *)new spot::translator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__translator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_translator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_translator", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_translator__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_translator__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_spot__option_map, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_translator__SWIG_4(self, argc, argv);
  }
check_3:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_translator__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_new_translator__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_translator__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_translator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::translator::translator(spot::tl_simplifier *,spot::option_map const *)\n"
    "    spot::translator::translator(spot::tl_simplifier *)\n"
    "    spot::translator::translator(spot::bdd_dict_ptr const &,spot::option_map const *)\n"
    "    spot::translator::translator(spot::bdd_dict_ptr const &)\n"
    "    spot::translator::translator(spot::option_map const *)\n"
    "    spot::translator::translator()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_translator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::translator *arg1 = (spot::translator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__translator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_translator" "', argument " "1"" of type '" "spot::translator *""'"); 
  }
  arg1 = reinterpret_cast< spot::translator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_translator_set_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::translator *arg1 = (spot::translator *) 0 ;
  spot::translator::output_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "translator_set_type", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__translator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "translator_set_type" "', argument " "1"" of type '" "spot::translator *""'"); 
  }
  arg1 = reinterpret_cast< spot::translator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "translator_set_type" "', argument " "2"" of type '" "spot::translator::output_type""'");
  } 
  arg2 = static_cast< spot::translator::output_type >(val2);
  {
    try {
      (arg1)->set_type(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_translator_set_pref(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::translator *arg1 = (spot::translator *) 0 ;
  spot::translator::output_pref arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "translator_set_pref", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__translator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "translator_set_pref" "', argument " "1"" of type '" "spot::translator *""'"); 
  }
  arg1 = reinterpret_cast< spot::translator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "translator_set_pref" "', argument " "2"" of type '" "spot::translator::output_pref""'");
  } 
  arg2 = static_cast< spot::translator::output_pref >(val2);
  {
    try {
      (arg1)->set_pref(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_translator_set_level(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::translator *arg1 = (spot::translator *) 0 ;
  spot::translator::optimization_level arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "translator_set_level", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__translator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "translator_set_level" "', argument " "1"" of type '" "spot::translator *""'"); 
  }
  arg1 = reinterpret_cast< spot::translator * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "translator_set_level" "', argument " "2"" of type '" "spot::translator::optimization_level""'");
  } 
  arg2 = static_cast< spot::translator::optimization_level >(val2);
  {
    try {
      (arg1)->set_level(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_translator_run__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::translator *arg1 = (spot::translator *) 0 ;
  spot::formula arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__translator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "translator_run" "', argument " "1"" of type '" "spot::translator *""'"); 
  }
  arg1 = reinterpret_cast< spot::translator * >(argp1);
  {
    void *tmp;
    int res = SWIG_ConvertPtr(swig_obj[1], &tmp, SWIGTYPE_p_spot__formula,
      SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in method '" "translator_run" "', argument " "2"" of type '" "spot::formula""'");
    }
    if (tmp) {
      spot::formula* temp = reinterpret_cast< spot::formula * >(tmp);
      arg2 = *temp;
      if (SWIG_IsNewObj(res)) delete temp;
    }
    // if tmp == nullptr, then the default value of arg2 is fine.
  }
  {
    try {
      result = (arg1)->run(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_translator_run__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::translator *arg1 = (spot::translator *) 0 ;
  spot::formula *arg2 = (spot::formula *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__translator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "translator_run" "', argument " "1"" of type '" "spot::translator *""'"); 
  }
  arg1 = reinterpret_cast< spot::translator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__formula, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "translator_run" "', argument " "2"" of type '" "spot::formula *""'"); 
  }
  arg2 = reinterpret_cast< spot::formula * >(argp2);
  {
    try {
      result = (arg1)->run(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_translator_run(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "translator_run", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__formula, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_translator_run__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_translator_run__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'translator_run'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::translator::run(spot::formula)\n"
    "    spot::translator::run(spot::formula *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_translator_clear_caches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::translator *arg1 = (spot::translator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__translator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "translator_clear_caches" "', argument " "1"" of type '" "spot::translator *""'"); 
  }
  arg1 = reinterpret_cast< spot::translator * >(argp1);
  {
    try {
      (arg1)->clear_caches();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *translator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__translator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *translator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_to_weak_alternating__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_weak_alternating" "', argument " "1"" of type '" "spot::const_twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_weak_alternating" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::to_weak_alternating(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_weak_alternating__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_weak_alternating" "', argument " "1"" of type '" "spot::const_twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::to_weak_alternating(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_weak_alternating(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "to_weak_alternating", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_to_weak_alternating__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_to_weak_alternating__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'to_weak_alternating'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::to_weak_alternating(spot::const_twa_graph_ptr &,bool)\n"
    "    spot::to_weak_alternating(spot::const_twa_graph_ptr &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_print_hoa__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_hoa" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_hoa" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_hoa" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_hoa" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (std::ostream *) &spot::print_hoa(*arg1,(std::shared_ptr< spot::twa const > const &)*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_hoa__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_twa_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_twa_ptr tempshared2 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_hoa" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_hoa" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_hoa" "', argument " "2"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_twa_ptr * >(argp2);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_twa_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::print_hoa(*arg1,(std::shared_ptr< spot::twa const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_hoa(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_hoa", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_print_hoa__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_print_hoa__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_hoa'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_hoa(std::ostream &,spot::const_twa_ptr const &,char const *)\n"
    "    spot::print_hoa(std::ostream &,spot::const_twa_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_get_aliases(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_aliases" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *)spot::get_aliases((std::shared_ptr< spot::twa const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_set_aliases(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_ptr arg1 ;
  std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "set_aliases", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_aliases" "', argument " "1"" of type '" "spot::twa_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_ptr * >(argp1);
  }
  {
    std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *ptr = (std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *)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 '" "set_aliases" "', argument " "2"" of type '" "std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      spot::set_aliases(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_hoa_alias_formater(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  char *arg6 = (char *) 0 ;
  char *arg7 = (char *) 0 ;
  char *arg8 = (char *) 0 ;
  SwigValueWrapper< std::function< std::string (int) > > arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  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 ;
  int res6 ;
  char *buf6 = 0 ;
  int alloc6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  int alloc7 = 0 ;
  int res8 ;
  char *buf8 = 0 ;
  int alloc8 = 0 ;
  void *argp9 ;
  int res9 = 0 ;
  PyObject *swig_obj[9] ;
  spot::hoa_alias_formater *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_hoa_alias_formater", 9, 9, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_hoa_alias_formater" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_hoa_alias_formater" "', argument " "2"" of type '" "char const *""'");
  }
  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_hoa_alias_formater" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_hoa_alias_formater" "', argument " "4"" of type '" "char const *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(swig_obj[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_hoa_alias_formater" "', argument " "5"" of type '" "char const *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  res6 = SWIG_AsCharPtrAndSize(swig_obj[5], &buf6, NULL, &alloc6);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_hoa_alias_formater" "', argument " "6"" of type '" "char const *""'");
  }
  arg6 = reinterpret_cast< char * >(buf6);
  res7 = SWIG_AsCharPtrAndSize(swig_obj[6], &buf7, NULL, &alloc7);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_hoa_alias_formater" "', argument " "7"" of type '" "char const *""'");
  }
  arg7 = reinterpret_cast< char * >(buf7);
  res8 = SWIG_AsCharPtrAndSize(swig_obj[7], &buf8, NULL, &alloc8);
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "new_hoa_alias_formater" "', argument " "8"" of type '" "char const *""'");
  }
  arg8 = reinterpret_cast< char * >(buf8);
  {
    res9 = SWIG_ConvertPtr(swig_obj[8], &argp9, SWIGTYPE_p_std__functionT_std__string_fintF_t,  0  | 0);
    if (!SWIG_IsOK(res9)) {
      SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_hoa_alias_formater" "', argument " "9"" of type '" "std::function< std::string (int) >""'"); 
    }  
    if (!argp9) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_hoa_alias_formater" "', argument " "9"" of type '" "std::function< std::string (int) >""'");
    } else {
      std::function< std::string (int) > * temp = reinterpret_cast< std::function< std::string (int) > * >(argp9);
      arg9 = *temp;
      if (SWIG_IsNewObj(res9)) delete temp;
    }
  }
  {
    try {
      result = (spot::hoa_alias_formater *)new spot::hoa_alias_formater((spot::const_twa_graph_ptr const &)*arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,(char const *)arg8,arg9);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__hoa_alias_formater, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
  if (alloc7 == SWIG_NEWOBJ) delete[] buf7;
  if (alloc8 == SWIG_NEWOBJ) delete[] buf8;
  return NULL;
}


SWIGINTERN PyObject *_wrap_hoa_alias_formater_encode_label__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::hoa_alias_formater *arg1 = (spot::hoa_alias_formater *) 0 ;
  bdd arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  std::string result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__hoa_alias_formater, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hoa_alias_formater_encode_label" "', argument " "1"" of type '" "spot::hoa_alias_formater *""'"); 
  }
  arg1 = reinterpret_cast< spot::hoa_alias_formater * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hoa_alias_formater_encode_label" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "hoa_alias_formater_encode_label" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "hoa_alias_formater_encode_label" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (arg1)->encode_label(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hoa_alias_formater_encode_label__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::hoa_alias_formater *arg1 = (spot::hoa_alias_formater *) 0 ;
  bdd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__hoa_alias_formater, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hoa_alias_formater_encode_label" "', argument " "1"" of type '" "spot::hoa_alias_formater *""'"); 
  }
  arg1 = reinterpret_cast< spot::hoa_alias_formater * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hoa_alias_formater_encode_label" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "hoa_alias_formater_encode_label" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (arg1)->encode_label(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hoa_alias_formater_encode_label(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "hoa_alias_formater_encode_label", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_hoa_alias_formater_encode_label__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_hoa_alias_formater_encode_label__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'hoa_alias_formater_encode_label'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::hoa_alias_formater::encode_label(bdd,unsigned int)\n"
    "    spot::hoa_alias_formater::encode_label(bdd)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_hoa_alias_formater_aliases(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::hoa_alias_formater *arg1 = (spot::hoa_alias_formater *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::hoa_alias_formater::aliases_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__hoa_alias_formater, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hoa_alias_formater_aliases" "', argument " "1"" of type '" "spot::hoa_alias_formater *""'"); 
  }
  arg1 = reinterpret_cast< spot::hoa_alias_formater * >(argp1);
  {
    try {
      result = (spot::hoa_alias_formater::aliases_t *)(arg1)->aliases();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_hoa_alias_formater(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::hoa_alias_formater *arg1 = (spot::hoa_alias_formater *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__hoa_alias_formater, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_hoa_alias_formater" "', argument " "1"" of type '" "spot::hoa_alias_formater *""'"); 
  }
  arg1 = reinterpret_cast< spot::hoa_alias_formater * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *hoa_alias_formater_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__hoa_alias_formater, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *hoa_alias_formater_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_dtwa_sat_synthetize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_synthetize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_synthetize" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_synthetize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_synthetize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_synthetize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_synthetize" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dtwa_sat_synthetize" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = spot::dtwa_sat_synthetize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_synthetize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_synthetize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_synthetize" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_synthetize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_synthetize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_synthetize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_synthetize" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = spot::dtwa_sat_synthetize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_synthetize__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_synthetize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_synthetize" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_synthetize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_synthetize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_synthetize" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = spot::dtwa_sat_synthetize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_synthetize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "dtwa_sat_synthetize", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    PyObject *retobj = _wrap_dtwa_sat_synthetize__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_dtwa_sat_synthetize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_dtwa_sat_synthetize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'dtwa_sat_synthetize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::dtwa_sat_synthetize(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,int,bool,bool)\n"
    "    spot::dtwa_sat_synthetize(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,int,bool)\n"
    "    spot::dtwa_sat_synthetize(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  int arg5 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dtwa_sat_minimize" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = spot::dtwa_sat_minimize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = spot::dtwa_sat_minimize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::dtwa_sat_minimize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  {
    try {
      result = spot::dtwa_sat_minimize((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "dtwa_sat_minimize", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_dtwa_sat_minimize__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_dtwa_sat_minimize__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_dtwa_sat_minimize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_dtwa_sat_minimize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'dtwa_sat_minimize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::dtwa_sat_minimize(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,int,bool)\n"
    "    spot::dtwa_sat_minimize(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,int)\n"
    "    spot::dtwa_sat_minimize(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool)\n"
    "    spot::dtwa_sat_minimize(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_dichotomy__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  int arg6 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = spot::dtwa_sat_minimize_dichotomy((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5,arg6,arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_dichotomy__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  int arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  {
    try {
      result = spot::dtwa_sat_minimize_dichotomy((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_dichotomy__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = spot::dtwa_sat_minimize_dichotomy((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_dichotomy__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::dtwa_sat_minimize_dichotomy((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_dichotomy__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_dichotomy" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  {
    try {
      result = spot::dtwa_sat_minimize_dichotomy((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_dichotomy(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "dtwa_sat_minimize_dichotomy", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_dichotomy__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_dichotomy__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_dichotomy__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_dichotomy__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_dichotomy__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'dtwa_sat_minimize_dichotomy'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::dtwa_sat_minimize_dichotomy(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,bool,int,bool)\n"
    "    spot::dtwa_sat_minimize_dichotomy(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,bool,int)\n"
    "    spot::dtwa_sat_minimize_dichotomy(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,bool)\n"
    "    spot::dtwa_sat_minimize_dichotomy(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool)\n"
    "    spot::dtwa_sat_minimize_dichotomy(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_incr__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  int arg5 ;
  bool arg6 ;
  int arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_incr" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_incr" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_incr" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_incr" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_incr" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize_incr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dtwa_sat_minimize_incr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dtwa_sat_minimize_incr" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  {
    try {
      result = spot::dtwa_sat_minimize_incr((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5,arg6,arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_incr__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  int arg5 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_incr" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_incr" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_incr" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_incr" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_incr" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize_incr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dtwa_sat_minimize_incr" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = spot::dtwa_sat_minimize_incr((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_incr__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_incr" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_incr" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_incr" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_incr" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_incr" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize_incr" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = spot::dtwa_sat_minimize_incr((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_incr__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_incr" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_incr" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_incr" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_incr" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_incr" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::dtwa_sat_minimize_incr((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_incr__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_incr" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_incr" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_incr" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_incr" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  {
    try {
      result = spot::dtwa_sat_minimize_incr((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_incr(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "dtwa_sat_minimize_incr", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_incr__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_incr__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_incr__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_incr__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_incr__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'dtwa_sat_minimize_incr'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::dtwa_sat_minimize_incr(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,int,bool,int)\n"
    "    spot::dtwa_sat_minimize_incr(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,int,bool)\n"
    "    spot::dtwa_sat_minimize_incr(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,int)\n"
    "    spot::dtwa_sat_minimize_incr(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool)\n"
    "    spot::dtwa_sat_minimize_incr(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_assume__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  int arg5 ;
  bool arg6 ;
  int arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_assume" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_assume" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_assume" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_assume" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_assume" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize_assume" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dtwa_sat_minimize_assume" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dtwa_sat_minimize_assume" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  {
    try {
      result = spot::dtwa_sat_minimize_assume((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5,arg6,arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_assume__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  int arg5 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_assume" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_assume" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_assume" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_assume" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_assume" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize_assume" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dtwa_sat_minimize_assume" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = spot::dtwa_sat_minimize_assume((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_assume__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  int arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_assume" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_assume" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_assume" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_assume" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_assume" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dtwa_sat_minimize_assume" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = spot::dtwa_sat_minimize_assume((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_assume__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_assume" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_assume" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_assume" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_assume" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dtwa_sat_minimize_assume" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::dtwa_sat_minimize_assume((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_assume__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::acc_cond::acc_code *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_sat_minimize_assume" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dtwa_sat_minimize_assume" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__acc_code,  0  | SWIG_POINTER_IMPLICIT_CONV);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dtwa_sat_minimize_assume" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dtwa_sat_minimize_assume" "', argument " "3"" of type '" "spot::acc_cond::acc_code const &""'"); 
  }
  arg3 = reinterpret_cast< spot::acc_cond::acc_code * >(argp3);
  {
    try {
      result = spot::dtwa_sat_minimize_assume((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,(spot::acc_cond::acc_code const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtwa_sat_minimize_assume(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "dtwa_sat_minimize_assume", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_assume__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_assume__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_assume__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_assume__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_dtwa_sat_minimize_assume__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'dtwa_sat_minimize_assume'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::dtwa_sat_minimize_assume(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,int,bool,int)\n"
    "    spot::dtwa_sat_minimize_assume(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,int,bool)\n"
    "    spot::dtwa_sat_minimize_assume(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool,int)\n"
    "    spot::dtwa_sat_minimize_assume(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &,bool)\n"
    "    spot::dtwa_sat_minimize_assume(spot::const_twa_graph_ptr const &,unsigned int,spot::acc_cond::acc_code const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_sat_minimize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sat_minimize" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sat_minimize" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sat_minimize" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::sat_minimize(SWIG_STD_MOVE(arg1),(char const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_sat_minimize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr arg1 ;
  char *arg2 = (char *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sat_minimize" "', argument " "1"" of type '" "spot::twa_graph_ptr""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sat_minimize" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = spot::sat_minimize(SWIG_STD_MOVE(arg1),(char const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_sat_minimize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "sat_minimize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_sat_minimize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_sat_minimize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'sat_minimize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::sat_minimize(spot::twa_graph_ptr,char const *,bool)\n"
    "    spot::sat_minimize(spot::twa_graph_ptr,char const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_relabel_here(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  spot::relabeling_map *arg2 = (spot::relabeling_map *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "relabel_here", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "relabel_here" "', argument " "2"" of type '" "spot::relabeling_map *""'"); 
  }
  arg2 = reinterpret_cast< spot::relabeling_map * >(argp2);
  {
    try {
      spot::relabel_here(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_relabel_here__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  bdd *arg5 = 0 ;
  std::string arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  spot::relabeling_map result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "partitioned_relabel_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "partitioned_relabel_here" "', 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 '" "partitioned_relabel_here" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "partitioned_relabel_here" "', argument " "5"" of type '" "bdd const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "partitioned_relabel_here" "', argument " "5"" of type '" "bdd const &""'"); 
  }
  arg5 = reinterpret_cast< bdd * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[5], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "partitioned_relabel_here" "', argument " "6"" of type '" "std::string""'"); 
    }
    arg6 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = spot::partitioned_relabel_here(*arg1,arg2,arg3,arg4,(bdd const &)*arg5,SWIG_STD_MOVE(arg6));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_relabel_here__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  bdd *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  spot::relabeling_map result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "partitioned_relabel_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "partitioned_relabel_here" "', 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 '" "partitioned_relabel_here" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "partitioned_relabel_here" "', argument " "5"" of type '" "bdd const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "partitioned_relabel_here" "', argument " "5"" of type '" "bdd const &""'"); 
  }
  arg5 = reinterpret_cast< bdd * >(argp5);
  {
    try {
      result = spot::partitioned_relabel_here(*arg1,arg2,arg3,arg4,(bdd const &)*arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_relabel_here__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  spot::relabeling_map result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "partitioned_relabel_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "partitioned_relabel_here" "', 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 '" "partitioned_relabel_here" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = spot::partitioned_relabel_here(*arg1,arg2,arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_relabel_here__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  unsigned int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  spot::relabeling_map result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "partitioned_relabel_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "partitioned_relabel_here" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = spot::partitioned_relabel_here(*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_relabel_here__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::relabeling_map result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "partitioned_relabel_here" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::partitioned_relabel_here(*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_relabel_here__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  spot::relabeling_map result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "partitioned_relabel_here" "', argument " "1"" of type '" "spot::twa_graph_ptr &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::partitioned_relabel_here(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_partitioned_relabel_here(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "partitioned_relabel_here", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_partitioned_relabel_here__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_partitioned_relabel_here__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_partitioned_relabel_here__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_partitioned_relabel_here__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_partitioned_relabel_here__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_partitioned_relabel_here__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'partitioned_relabel_here'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::partitioned_relabel_here(spot::twa_graph_ptr &,bool,unsigned int,unsigned int,bdd const &,std::string)\n"
    "    spot::partitioned_relabel_here(spot::twa_graph_ptr &,bool,unsigned int,unsigned int,bdd const &)\n"
    "    spot::partitioned_relabel_here(spot::twa_graph_ptr &,bool,unsigned int,unsigned int)\n"
    "    spot::partitioned_relabel_here(spot::twa_graph_ptr &,bool,unsigned int)\n"
    "    spot::partitioned_relabel_here(spot::twa_graph_ptr &,bool)\n"
    "    spot::partitioned_relabel_here(spot::twa_graph_ptr &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_twa_word__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  spot::twa_word *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_word" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::twa_word *)new spot::twa_word((spot::bdd_dict_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_word > *smartresult = result ? new std::shared_ptr<  spot::twa_word >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_word__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_run_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_run_ptr tempshared1 ;
  spot::twa_word *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_twa_word" "', argument " "1"" of type '" "spot::twa_run_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_run_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_run_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_run_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::twa_word *)new spot::twa_word((spot::twa_run_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_word > *smartresult = result ? new std::shared_ptr<  spot::twa_word >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_twa_word(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_twa_word", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_twa_word__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_twa_word__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_twa_word'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_word::twa_word(spot::bdd_dict_ptr const &)\n"
    "    spot::twa_word::twa_word(spot::twa_run_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_twa_word(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word > tempshared1 ;
  std::shared_ptr< spot::twa_word > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_twa_word" "', argument " "1"" of type '" "spot::twa_word *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_word_simplify(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word > tempshared1 ;
  std::shared_ptr< spot::twa_word > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_word_simplify" "', argument " "1"" of type '" "spot::twa_word *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->simplify();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_word_use_all_aps__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  bdd arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word > tempshared1 ;
  std::shared_ptr< spot::twa_word > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_word_use_all_aps" "', argument " "1"" of type '" "spot::twa_word *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_word_use_all_aps" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_word_use_all_aps" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "twa_word_use_all_aps" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      (arg1)->use_all_aps(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_word_use_all_aps__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  bdd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word > tempshared1 ;
  std::shared_ptr< spot::twa_word > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_word_use_all_aps" "', argument " "1"" of type '" "spot::twa_word *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_word_use_all_aps" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "twa_word_use_all_aps" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->use_all_aps(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_word_use_all_aps(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "twa_word_use_all_aps", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_twa_word_use_all_aps__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_twa_word_use_all_aps__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'twa_word_use_all_aps'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::twa_word::use_all_aps(bdd,bool)\n"
    "    spot::twa_word::use_all_aps(bdd)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_twa_word_prefix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  spot::twa_word::seq_t *arg2 = (spot::twa_word::seq_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word > tempshared1 ;
  std::shared_ptr< spot::twa_word > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_word_prefix_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_word_prefix_set" "', argument " "1"" of type '" "spot::twa_word *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_word_prefix_set" "', argument " "2"" of type '" "spot::twa_word::seq_t *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_word::seq_t * >(argp2);
  if (arg1) (arg1)->prefix = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_word_prefix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word > tempshared1 ;
  std::shared_ptr< spot::twa_word > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_word::seq_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_word_prefix_get" "', argument " "1"" of type '" "spot::twa_word *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::twa_word::seq_t *)& ((arg1)->prefix);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_word_cycle_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  spot::twa_word::seq_t *arg2 = (spot::twa_word::seq_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word > tempshared1 ;
  std::shared_ptr< spot::twa_word > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "twa_word_cycle_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_word_cycle_set" "', argument " "1"" of type '" "spot::twa_word *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "twa_word_cycle_set" "', argument " "2"" of type '" "spot::twa_word::seq_t *""'"); 
  }
  arg2 = reinterpret_cast< spot::twa_word::seq_t * >(argp2);
  if (arg1) (arg1)->cycle = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_word_cycle_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word > tempshared1 ;
  std::shared_ptr< spot::twa_word > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_word::seq_t *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_word_cycle_get" "', argument " "1"" of type '" "spot::twa_word *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::twa_word::seq_t *)& ((arg1)->cycle);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_word_get_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word const > tempshared1 ;
  std::shared_ptr< spot::twa_word const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::bdd_dict_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_word_get_dict" "', argument " "1"" of type '" "spot::twa_word const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa_word const *)arg1)->get_dict();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::bdd_dict > *smartresult = result ? new std::shared_ptr<  spot::bdd_dict >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_word_as_automaton(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word const > tempshared1 ;
  std::shared_ptr< spot::twa_word const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_word_as_automaton" "', argument " "1"" of type '" "spot::twa_word const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::twa_word const *)arg1)->as_automaton();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twa_word___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_word *arg1 = (spot::twa_word *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::twa_word > tempshared1 ;
  std::shared_ptr< spot::twa_word > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "twa_word___str__" "', argument " "1"" of type '" "spot::twa_word *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::twa_word > * >(argp1);
      arg1 = const_cast< spot::twa_word * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = spot_twa_word___str__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *twa_word_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *twa_word_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_make_twa_word__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  spot::twa_word_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_twa_word" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::make_twa_word((std::shared_ptr< spot::bdd_dict > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_word > *smartresult = result ? new std::shared_ptr<  spot::twa_word >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_twa_word__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::twa_run_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_run_ptr tempshared1 ;
  spot::twa_word_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_run_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_twa_word" "', argument " "1"" of type '" "spot::twa_run_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_run_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_run_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_run_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::make_twa_word((std::shared_ptr< spot::twa_run > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_word > *smartresult = result ? new std::shared_ptr<  spot::twa_word >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_twa_word(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "make_twa_word", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_make_twa_word__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_make_twa_word__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'make_twa_word'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::make_twa_word(spot::bdd_dict_ptr const &)\n"
    "    spot::make_twa_word(spot::twa_run_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_parse_word(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  spot::twa_word_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "parse_word", 2, 2, swig_obj)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_word" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_word" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_word" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::parse_word((std::string const &)*arg1,(std::shared_ptr< spot::bdd_dict > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_word > *smartresult = result ? new std::shared_ptr<  spot::twa_word >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_word_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_iterator" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_list_Sl_bdd_Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___nonzero__" "', argument " "1"" of type '" "std::list< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = (bool)std_list_Sl_bdd_Sg____nonzero__((std::list< bdd > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___bool__" "', argument " "1"" of type '" "std::list< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = (bool)std_list_Sl_bdd_Sg____bool__((std::list< bdd > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< bdd >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___len__" "', argument " "1"" of type '" "std::list< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = std_list_Sl_bdd_Sg____len__((std::list< bdd > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::difference_type arg2 ;
  std::list< bdd >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::list< bdd,std::allocator< bdd > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_bdd___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___getslice__" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_bdd___getslice__" "', argument " "2"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::list< bdd >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "list_bdd___getslice__" "', argument " "3"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg3 = static_cast< std::list< bdd >::difference_type >(val3);
  {
    try {
      try {
        result = (std::list< bdd,std::allocator< bdd > > *)std_list_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::difference_type arg2 ;
  std::list< bdd >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___setslice__" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_bdd___setslice__" "', argument " "2"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::list< bdd >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "list_bdd___setslice__" "', argument " "3"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg3 = static_cast< std::list< bdd >::difference_type >(val3);
  {
    try {
      try {
        std_list_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::difference_type arg2 ;
  std::list< bdd >::difference_type arg3 ;
  std::list< bdd,std::allocator< bdd > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___setslice__" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_bdd___setslice__" "', argument " "2"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::list< bdd >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "list_bdd___setslice__" "', argument " "3"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg3 = static_cast< std::list< bdd >::difference_type >(val3);
  {
    std::list< bdd,std::allocator< bdd > > *ptr = (std::list< bdd,std::allocator< bdd > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "list_bdd___setslice__" "', argument " "4"" of type '" "std::list< bdd,std::allocator< bdd > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd___setslice__" "', argument " "4"" of type '" "std::list< bdd,std::allocator< bdd > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_list_Sl_bdd_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::list< bdd,std::allocator< bdd > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_bdd___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_list_bdd___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_list_bdd___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_bdd___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< bdd >::__setslice__(std::list< bdd >::difference_type,std::list< bdd >::difference_type)\n"
    "    std::list< bdd >::__setslice__(std::list< bdd >::difference_type,std::list< bdd >::difference_type,std::list< bdd,std::allocator< bdd > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_bdd___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::difference_type arg2 ;
  std::list< bdd >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_bdd___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___delslice__" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_bdd___delslice__" "', argument " "2"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::list< bdd >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "list_bdd___delslice__" "', argument " "3"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg3 = static_cast< std::list< bdd >::difference_type >(val3);
  {
    try {
      try {
        std_list_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___delitem__" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_bdd___delitem__" "', argument " "2"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::list< bdd >::difference_type >(val2);
  {
    try {
      try {
        std_list_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::list< bdd,std::allocator< bdd > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___getitem__" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_bdd___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::list< bdd,std::allocator< bdd > > *)std_list_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::list< bdd,std::allocator< bdd > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___setitem__" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_bdd___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::list< bdd,std::allocator< bdd > > *ptr = (std::list< bdd,std::allocator< bdd > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "list_bdd___setitem__" "', argument " "3"" of type '" "std::list< bdd,std::allocator< bdd > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd___setitem__" "', argument " "3"" of type '" "std::list< bdd,std::allocator< bdd > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_list_Sl_bdd_Sg____setitem____SWIG_0(arg1,arg2,(std::list< bdd,std::allocator< bdd > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___setitem__" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_bdd___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_list_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___delitem__" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_bdd___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_list_Sl_bdd_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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_bdd___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_list_bdd___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_list_bdd___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_bdd___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< bdd >::__delitem__(std::list< bdd >::difference_type)\n"
    "    std::list< bdd >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_bdd___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::list< bdd >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___getitem__" "', argument " "1"" of type '" "std::list< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_bdd___getitem__" "', argument " "2"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::list< bdd >::difference_type >(val2);
  {
    try {
      try {
        result = (std::list< bdd >::value_type *) &std_list_Sl_bdd_Sg____getitem____SWIG_1((std::list< bdd > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bdd, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::list< bdd >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_bdd___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_list_bdd___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_list_bdd___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_bdd___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< bdd >::__getitem__(PySliceObject *)\n"
    "    std::list< bdd >::__getitem__(std::list< bdd >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_bdd___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::difference_type arg2 ;
  std::list< bdd >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd___setitem__" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_bdd___setitem__" "', argument " "2"" of type '" "std::list< bdd >::difference_type""'");
  } 
  arg2 = static_cast< std::list< bdd >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "list_bdd___setitem__" "', argument " "3"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd___setitem__" "', argument " "3"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< bdd >::value_type * >(argp3);
  {
    try {
      try {
        std_list_Sl_bdd_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(bdd const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_bdd___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_list_bdd___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::list< bdd,std::allocator< bdd > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_list_bdd___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_list_bdd___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_bdd___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< bdd >::__setitem__(PySliceObject *,std::list< bdd,std::allocator< bdd > > const &)\n"
    "    std::list< bdd >::__setitem__(PySliceObject *)\n"
    "    std::list< bdd >::__setitem__(std::list< bdd >::difference_type,std::list< bdd >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_bdd_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< bdd >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_pop" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      try {
        result = std_list_Sl_bdd_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::list< bdd >::value_type(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_bdd_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_append" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "list_bdd_append" "', argument " "2"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd_append" "', argument " "2"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< bdd >::value_type * >(argp2);
  {
    try {
      std_list_Sl_bdd_Sg__append(arg1,(bdd const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_list_bdd__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::list< bdd > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::list< bdd > *)new std::list< bdd >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_list_bdd__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::list< bdd > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::list< bdd,std::allocator< bdd > > *ptr = (std::list< bdd,std::allocator< bdd > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_list_bdd" "', argument " "1"" of type '" "std::list< bdd > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_list_bdd" "', argument " "1"" of type '" "std::list< bdd > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::list< bdd > *)new std::list< bdd >((std::list< bdd > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_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_list_bdd_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_empty" "', argument " "1"" of type '" "std::list< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = (bool)((std::list< bdd > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< bdd >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_size" "', argument " "1"" of type '" "std::list< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = ((std::list< bdd > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_bdd_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_swap" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "list_bdd_swap" "', argument " "2"" of type '" "std::list< bdd > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd_swap" "', argument " "2"" of type '" "std::list< bdd > &""'"); 
  }
  arg2 = reinterpret_cast< std::list< bdd > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< bdd >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_begin" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< bdd >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< bdd >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_end" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< bdd >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< bdd >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_rbegin" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< bdd >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< bdd >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_rend" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< bdd >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_clear" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< bdd > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_get_allocator" "', argument " "1"" of type '" "std::list< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = ((std::list< bdd > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::list< bdd >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_bdd_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_list_bdd__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::list< bdd > *result = 0 ;
  
  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_list_bdd" "', argument " "1"" of type '" "std::list< bdd >::size_type""'");
  } 
  arg1 = static_cast< std::list< bdd >::size_type >(val1);
  {
    try {
      result = (std::list< bdd > *)new std::list< bdd >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_pop_back" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_resize" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_bdd_resize" "', argument " "2"" of type '" "std::list< bdd >::size_type""'");
  } 
  arg2 = static_cast< std::list< bdd >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::list< bdd >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_erase" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(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 '" "list_bdd_erase" "', argument " "2"" of type '" "std::list< bdd >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< bdd >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< bdd >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_bdd_erase" "', argument " "2"" of type '" "std::list< bdd >::iterator""'");
    }
  }
  {
    try {
      result = std_list_Sl_bdd_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< bdd >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::iterator arg2 ;
  std::list< bdd >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::list< bdd >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_erase" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(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 '" "list_bdd_erase" "', argument " "2"" of type '" "std::list< bdd >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< bdd >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< bdd >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_bdd_erase" "', argument " "2"" of type '" "std::list< bdd >::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 '" "list_bdd_erase" "', argument " "3"" of type '" "std::list< bdd >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< bdd >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< bdd >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_bdd_erase" "', argument " "3"" of type '" "std::list< bdd >::iterator""'");
    }
  }
  {
    try {
      result = std_list_Sl_bdd_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< bdd >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_bdd_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_list_bdd_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_list_bdd_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_bdd_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< bdd >::erase(std::list< bdd >::iterator)\n"
    "    std::list< bdd >::erase(std::list< bdd >::iterator,std::list< bdd >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_list_bdd__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd >::size_type arg1 ;
  std::list< bdd >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::list< bdd > *result = 0 ;
  
  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_list_bdd" "', argument " "1"" of type '" "std::list< bdd >::size_type""'");
  } 
  arg1 = static_cast< std::list< bdd >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_list_bdd" "', argument " "2"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_list_bdd" "', argument " "2"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< bdd >::value_type * >(argp2);
  {
    try {
      result = (std::list< bdd > *)new std::list< bdd >(arg1,(std::list< bdd >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_list_bdd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_list_bdd", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_list_bdd__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_list_bdd__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_list_bdd__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_list_bdd__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_list_bdd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< bdd >::list()\n"
    "    std::list< bdd >::list(std::list< bdd > const &)\n"
    "    std::list< bdd >::list(std::list< bdd >::size_type)\n"
    "    std::list< bdd >::list(std::list< bdd >::size_type,std::list< bdd >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_bdd_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_bdd_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_push_back" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "list_bdd_push_back" "', argument " "2"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd_push_back" "', argument " "2"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< bdd >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::list< bdd >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< bdd >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_front" "', argument " "1"" of type '" "std::list< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = (std::list< bdd >::value_type *) &((std::list< bdd > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bdd, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::list< bdd >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::list< bdd >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_back" "', argument " "1"" of type '" "std::list< bdd > const *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      result = (std::list< bdd >::value_type *) &((std::list< bdd > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_bdd, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::list< bdd >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::size_type arg2 ;
  std::list< bdd >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_bdd_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_assign" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_bdd_assign" "', argument " "2"" of type '" "std::list< bdd >::size_type""'");
  } 
  arg2 = static_cast< std::list< bdd >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "list_bdd_assign" "', argument " "3"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd_assign" "', argument " "3"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< bdd >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::list< bdd >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::size_type arg2 ;
  std::list< bdd >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_resize" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "list_bdd_resize" "', argument " "2"" of type '" "std::list< bdd >::size_type""'");
  } 
  arg2 = static_cast< std::list< bdd >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "list_bdd_resize" "', argument " "3"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd_resize" "', argument " "3"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< bdd >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::list< bdd >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_bdd_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_list_bdd_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_list_bdd_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_bdd_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< bdd >::resize(std::list< bdd >::size_type)\n"
    "    std::list< bdd >::resize(std::list< bdd >::size_type,std::list< bdd >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_bdd_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::iterator arg2 ;
  std::list< bdd >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::list< bdd >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_insert" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(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 '" "list_bdd_insert" "', argument " "2"" of type '" "std::list< bdd >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< bdd >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< bdd >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_bdd_insert" "', argument " "2"" of type '" "std::list< bdd >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "list_bdd_insert" "', argument " "3"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd_insert" "', argument " "3"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::list< bdd >::value_type * >(argp3);
  {
    try {
      result = std_list_Sl_bdd_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(bdd const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::list< bdd >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::iterator arg2 ;
  std::list< bdd >::size_type arg3 ;
  std::list< bdd >::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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_insert" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(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 '" "list_bdd_insert" "', argument " "2"" of type '" "std::list< bdd >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::list< bdd >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::list< bdd >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "list_bdd_insert" "', argument " "2"" of type '" "std::list< bdd >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "list_bdd_insert" "', argument " "3"" of type '" "std::list< bdd >::size_type""'");
  } 
  arg3 = static_cast< std::list< bdd >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "list_bdd_insert" "', argument " "4"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd_insert" "', argument " "4"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::list< bdd >::value_type * >(argp4);
  {
    try {
      std_list_Sl_bdd_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(bdd const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "list_bdd_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_list_bdd_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_list_bdd_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'list_bdd_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::list< bdd >::insert(std::list< bdd >::iterator,std::list< bdd >::value_type const &)\n"
    "    std::list< bdd >::insert(std::list< bdd >::iterator,std::list< bdd >::size_type,std::list< bdd >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_list_bdd_pop_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_pop_front" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      (arg1)->pop_front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_push_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  std::list< bdd >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "list_bdd_push_front", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_push_front" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "list_bdd_push_front" "', argument " "2"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "list_bdd_push_front" "', argument " "2"" of type '" "std::list< bdd >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::list< bdd >::value_type * >(argp2);
  {
    try {
      (arg1)->push_front((std::list< bdd >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_list_bdd_reverse(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "list_bdd_reverse" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      (arg1)->reverse();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_list_bdd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::list< bdd > *arg1 = (std::list< bdd > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_list_bdd" "', argument " "1"" of type '" "std::list< bdd > *""'"); 
  }
  arg1 = reinterpret_cast< std::list< bdd > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *list_bdd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__listT_bdd_std__allocatorT_bdd_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *list_bdd_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_isomorphism_checker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::isomorphism_checker *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_isomorphism_checker" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    try {
      result = (spot::isomorphism_checker *)new spot::isomorphism_checker(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__isomorphism_checker, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_isomorphism_checker_is_isomorphic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::isomorphism_checker *arg1 = (spot::isomorphism_checker *) 0 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "isomorphism_checker_is_isomorphic", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__isomorphism_checker, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isomorphism_checker_is_isomorphic" "', argument " "1"" of type '" "spot::isomorphism_checker *""'"); 
  }
  arg1 = reinterpret_cast< spot::isomorphism_checker * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isomorphism_checker_is_isomorphic" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (bool)(arg1)->is_isomorphic(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_isomorphism_checker_are_isomorphic(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr arg1 ;
  spot::const_twa_graph_ptr arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "isomorphism_checker_are_isomorphic", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isomorphism_checker_are_isomorphic" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const""'");
    }
    if (argp1) arg1 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp1));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "isomorphism_checker_are_isomorphic" "', argument " "2"" of type '" "spot::const_twa_graph_ptr const""'");
    }
    if (argp2) arg2 = *(reinterpret_cast< spot::const_twa_graph_ptr * >(argp2));
    if (newmem & SWIG_CAST_NEW_MEMORY) delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp2);
  }
  {
    try {
      result = (bool)spot::isomorphism_checker::are_isomorphic(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_isomorphism_checker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::isomorphism_checker *arg1 = (spot::isomorphism_checker *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__isomorphism_checker, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_isomorphism_checker" "', argument " "1"" of type '" "spot::isomorphism_checker *""'"); 
  }
  arg1 = reinterpret_cast< spot::isomorphism_checker * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *isomorphism_checker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__isomorphism_checker, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *isomorphism_checker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_to_parity_data_nb_states_created_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_data *arg1 = (spot::to_parity_data *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_data_nb_states_created_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_data_nb_states_created_set" "', argument " "1"" of type '" "spot::to_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_data * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_data_nb_states_created_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->nb_states_created = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_data_nb_states_created_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_data *arg1 = (spot::to_parity_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_data_nb_states_created_get" "', argument " "1"" of type '" "spot::to_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_data * >(argp1);
  result = (unsigned int) ((arg1)->nb_states_created);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_data_nb_edges_created_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_data *arg1 = (spot::to_parity_data *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_data_nb_edges_created_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_data_nb_edges_created_set" "', argument " "1"" of type '" "spot::to_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_data * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_data_nb_edges_created_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->nb_edges_created = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_data_nb_edges_created_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_data *arg1 = (spot::to_parity_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_data_nb_edges_created_get" "', argument " "1"" of type '" "spot::to_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_data * >(argp1);
  result = (unsigned int) ((arg1)->nb_edges_created);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_data_algorithms_used_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_data *arg1 = (spot::to_parity_data *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_data_algorithms_used_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_data_algorithms_used_set" "', argument " "1"" of type '" "spot::to_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_data * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "to_parity_data_algorithms_used_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->algorithms_used = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_data_algorithms_used_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_data *arg1 = (spot::to_parity_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_data, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_data_algorithms_used_get" "', argument " "1"" of type '" "spot::to_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_data * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->algorithms_used);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_to_parity_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_data *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_to_parity_data", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::to_parity_data *)new spot::to_parity_data();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__to_parity_data, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_to_parity_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_data *arg1 = (spot::to_parity_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_to_parity_data" "', argument " "1"" of type '" "spot::to_parity_data *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_data * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *to_parity_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__to_parity_data, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *to_parity_data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_to_parity_options_search_ex_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_search_ex_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_search_ex_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_search_ex_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->search_ex = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_search_ex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_search_ex_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->search_ex);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_use_last_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_use_last_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_use_last_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_use_last_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->use_last = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_use_last_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_use_last_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->use_last);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_use_last_post_process_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_use_last_post_process_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_use_last_post_process_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_use_last_post_process_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->use_last_post_process = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_use_last_post_process_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_use_last_post_process_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->use_last_post_process);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_force_order_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_force_order_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_force_order_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_force_order_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->force_order = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_force_order_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_force_order_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->force_order);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_partial_degen_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_partial_degen_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_partial_degen_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_partial_degen_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->partial_degen = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_partial_degen_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_partial_degen_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->partial_degen);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_acc_clean_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_acc_clean_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_acc_clean_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_acc_clean_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->acc_clean = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_acc_clean_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_acc_clean_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->acc_clean);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_parity_equiv_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_parity_equiv_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_parity_equiv_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_parity_equiv_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->parity_equiv = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_parity_equiv_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_parity_equiv_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->parity_equiv);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_car_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_car_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_car_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_car_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->car = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_car_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_car_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->car);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_tar_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_tar_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_tar_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_tar_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->tar = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_tar_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_tar_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->tar);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_iar_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_iar_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_iar_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_iar_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->iar = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_iar_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_iar_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->iar);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_lar_dfs_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_lar_dfs_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_lar_dfs_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_lar_dfs_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->lar_dfs = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_lar_dfs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_lar_dfs_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->lar_dfs);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_bscc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_bscc_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_bscc_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_bscc_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->bscc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_bscc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_bscc_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->bscc);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_parity_prefix_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_parity_prefix_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_parity_prefix_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_parity_prefix_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->parity_prefix = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_parity_prefix_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_parity_prefix_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->parity_prefix);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_parity_prefix_general_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_parity_prefix_general_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_parity_prefix_general_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_parity_prefix_general_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->parity_prefix_general = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_parity_prefix_general_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_parity_prefix_general_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->parity_prefix_general);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_generic_emptiness_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_generic_emptiness_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_generic_emptiness_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_generic_emptiness_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->generic_emptiness = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_generic_emptiness_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_generic_emptiness_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->generic_emptiness);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_rabin_to_buchi_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_rabin_to_buchi_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_rabin_to_buchi_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_rabin_to_buchi_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->rabin_to_buchi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_rabin_to_buchi_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_rabin_to_buchi_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->rabin_to_buchi);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_buchi_type_to_buchi_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_buchi_type_to_buchi_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_buchi_type_to_buchi_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_buchi_type_to_buchi_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->buchi_type_to_buchi = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_buchi_type_to_buchi_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_buchi_type_to_buchi_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->buchi_type_to_buchi);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_parity_type_to_parity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_parity_type_to_parity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_parity_type_to_parity_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_parity_type_to_parity_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->parity_type_to_parity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_parity_type_to_parity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_parity_type_to_parity_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->parity_type_to_parity);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_reduce_col_deg_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_reduce_col_deg_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_reduce_col_deg_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_reduce_col_deg_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->reduce_col_deg = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_reduce_col_deg_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_reduce_col_deg_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->reduce_col_deg);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_propagate_col_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_propagate_col_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_propagate_col_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_propagate_col_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->propagate_col = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_propagate_col_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_propagate_col_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->propagate_col);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_use_generalized_rabin_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_use_generalized_rabin_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_use_generalized_rabin_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_use_generalized_rabin_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->use_generalized_rabin = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_use_generalized_rabin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_use_generalized_rabin_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->use_generalized_rabin);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_pretty_print_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_pretty_print_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_pretty_print_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_options_pretty_print_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->pretty_print = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_pretty_print_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_pretty_print_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (bool) ((arg1)->pretty_print);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_datas_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  spot::to_parity_data *arg2 = (spot::to_parity_data *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "to_parity_options_datas_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_datas_set" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__to_parity_data, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "to_parity_options_datas_set" "', argument " "2"" of type '" "spot::to_parity_data *""'"); 
  }
  arg2 = reinterpret_cast< spot::to_parity_data * >(argp2);
  if (arg1) (arg1)->datas = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_options_datas_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::to_parity_data *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_options_datas_get" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  result = (spot::to_parity_data *) ((arg1)->datas);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__to_parity_data, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_to_parity_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_to_parity_options", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::to_parity_options *)new spot::to_parity_options();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__to_parity_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_to_parity_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::to_parity_options *arg1 = (spot::to_parity_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__to_parity_options, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_to_parity_options" "', argument " "1"" of type '" "spot::to_parity_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::to_parity_options * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *to_parity_options_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__to_parity_options, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *to_parity_options_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_to_parity__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::to_parity_options arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__to_parity_options,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "to_parity" "', argument " "2"" of type '" "spot::to_parity_options const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "to_parity" "', argument " "2"" of type '" "spot::to_parity_options const""'");
    } else {
      spot::to_parity_options * temp = reinterpret_cast< spot::to_parity_options * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::to_parity((std::shared_ptr< spot::twa_graph const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::to_parity((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "to_parity", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_to_parity__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_to_parity__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'to_parity'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::to_parity(spot::const_twa_graph_ptr const &,spot::to_parity_options const)\n"
    "    spot::to_parity(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_to_parity_old__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_old" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "to_parity_old" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::to_parity_old((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_old__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "to_parity_old" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::to_parity_old((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_to_parity_old(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "to_parity_old", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_to_parity_old__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_to_parity_old__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'to_parity_old'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::to_parity_old(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::to_parity_old(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_iar__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iar" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iar" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::iar((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iar__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iar" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::iar((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iar(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "iar", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_iar__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_iar__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'iar'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::iar(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::iar(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_iar_maybe__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iar_maybe" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "iar_maybe" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::iar_maybe((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iar_maybe__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "iar_maybe" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::iar_maybe((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iar_maybe(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "iar_maybe", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_iar_maybe__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_iar_maybe__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'iar_maybe'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::iar_maybe(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::iar_maybe(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_parity_type_to_parity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parity_type_to_parity" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::parity_type_to_parity((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_buchi_type_to_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "buchi_type_to_buchi" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::buchi_type_to_buchi((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_co_buchi_type_to_co_buchi(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "co_buchi_type_to_co_buchi" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::co_buchi_type_to_co_buchi((std::shared_ptr< spot::twa_graph > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zielonka_tree__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = 0 ;
  spot::zielonka_tree_options arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::zielonka_tree *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zielonka_tree" "', argument " "1"" of type '" "spot::acc_cond const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_zielonka_tree" "', argument " "1"" of type '" "spot::acc_cond const &""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_zielonka_tree" "', argument " "2"" of type '" "spot::zielonka_tree_options""'");
  } 
  arg2 = static_cast< spot::zielonka_tree_options >(val2);
  {
    try {
      result = (spot::zielonka_tree *)new spot::zielonka_tree((spot::acc_cond const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__zielonka_tree, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zielonka_tree__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acc_cond *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::zielonka_tree *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__acc_cond,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_zielonka_tree" "', argument " "1"" of type '" "spot::acc_cond const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_zielonka_tree" "', argument " "1"" of type '" "spot::acc_cond const &""'"); 
  }
  arg1 = reinterpret_cast< spot::acc_cond * >(argp1);
  {
    try {
      result = (spot::zielonka_tree *)new spot::zielonka_tree((spot::acc_cond const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__zielonka_tree, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_zielonka_tree(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_zielonka_tree", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_zielonka_tree__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_zielonka_tree__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_zielonka_tree'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::zielonka_tree::zielonka_tree(spot::acc_cond const &,spot::zielonka_tree_options)\n"
    "    spot::zielonka_tree::zielonka_tree(spot::acc_cond const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_zielonka_tree_num_branches(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_num_branches" "', argument " "1"" of type '" "spot::zielonka_tree const *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  {
    try {
      result = (unsigned int)((spot::zielonka_tree const *)arg1)->num_branches();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zielonka_tree_first_branch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_first_branch" "', argument " "1"" of type '" "spot::zielonka_tree const *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  {
    try {
      result = (unsigned int)((spot::zielonka_tree const *)arg1)->first_branch();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zielonka_tree_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  unsigned int arg2 ;
  spot::acc_cond::mark_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  std::pair< unsigned int,unsigned int > result;
  
  if (!SWIG_Python_UnpackTuple(args, "zielonka_tree_step", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_step" "', argument " "1"" of type '" "spot::zielonka_tree const *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "zielonka_tree_step" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "zielonka_tree_step" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "zielonka_tree_step" "', argument " "3"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = ((spot::zielonka_tree const *)arg1)->step(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zielonka_tree_is_even(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_is_even" "', argument " "1"" of type '" "spot::zielonka_tree const *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  {
    try {
      result = (bool)((spot::zielonka_tree const *)arg1)->is_even();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zielonka_tree_has_rabin_shape(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_has_rabin_shape" "', argument " "1"" of type '" "spot::zielonka_tree const *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  {
    try {
      result = (bool)((spot::zielonka_tree const *)arg1)->has_rabin_shape();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zielonka_tree_has_streett_shape(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_has_streett_shape" "', argument " "1"" of type '" "spot::zielonka_tree const *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  {
    try {
      result = (bool)((spot::zielonka_tree const *)arg1)->has_streett_shape();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zielonka_tree_has_parity_shape(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_has_parity_shape" "', argument " "1"" of type '" "spot::zielonka_tree const *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  {
    try {
      result = (bool)((spot::zielonka_tree const *)arg1)->has_parity_shape();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zielonka_tree_dot(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "zielonka_tree_dot", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_dot" "', argument " "1"" of type '" "spot::zielonka_tree const *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zielonka_tree_dot" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "zielonka_tree_dot" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      ((spot::zielonka_tree const *)arg1)->dot(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zielonka_tree_nodes__set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  std::vector< spot::zielonka_tree::zielonka_node,std::allocator< spot::zielonka_tree::zielonka_node > > *arg2 = (std::vector< spot::zielonka_tree::zielonka_node,std::allocator< spot::zielonka_tree::zielonka_node > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "zielonka_tree_nodes__set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_nodes__set" "', argument " "1"" of type '" "spot::zielonka_tree *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__vectorT_spot__zielonka_tree__zielonka_node_std__allocatorT_spot__zielonka_tree__zielonka_node_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "zielonka_tree_nodes__set" "', argument " "2"" of type '" "std::vector< spot::zielonka_tree::zielonka_node,std::allocator< spot::zielonka_tree::zielonka_node > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::zielonka_tree::zielonka_node,std::allocator< spot::zielonka_tree::zielonka_node > > * >(argp2);
  if (arg1) (arg1)->nodes_ = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_zielonka_tree_nodes__get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::zielonka_tree::zielonka_node,std::allocator< spot::zielonka_tree::zielonka_node > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_nodes__get" "', argument " "1"" of type '" "spot::zielonka_tree *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  result = (std::vector< spot::zielonka_tree::zielonka_node,std::allocator< spot::zielonka_tree::zielonka_node > > *)& ((arg1)->nodes_);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__zielonka_tree__zielonka_node_std__allocatorT_spot__zielonka_tree__zielonka_node_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_zielonka_tree(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::zielonka_tree *arg1 = (spot::zielonka_tree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__zielonka_tree, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_zielonka_tree" "', argument " "1"" of type '" "spot::zielonka_tree *""'"); 
  }
  arg1 = reinterpret_cast< spot::zielonka_tree * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *zielonka_tree_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__zielonka_tree, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *zielonka_tree_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_zielonka_tree_transform(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zielonka_tree_transform" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::zielonka_tree_transform((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acd__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  spot::acd_options arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::acd *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_acd" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_acd" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_acd" "', argument " "2"" of type '" "spot::acd_options""'");
  } 
  arg2 = static_cast< spot::acd_options >(val2);
  {
    try {
      result = (spot::acd *)new spot::acd((spot::scc_info const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acd__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::scc_info *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::acd *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__scc_info,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_acd" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_acd" "', argument " "1"" of type '" "spot::scc_info const &""'"); 
  }
  arg1 = reinterpret_cast< spot::scc_info * >(argp1);
  {
    try {
      result = (spot::acd *)new spot::acd((spot::scc_info const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acd__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::acd_options arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  int val2 ;
  int ecode2 = 0 ;
  spot::acd *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_acd" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_acd" "', argument " "2"" of type '" "spot::acd_options""'");
  } 
  arg2 = static_cast< spot::acd_options >(val2);
  {
    try {
      result = (spot::acd *)new spot::acd((spot::const_twa_graph_ptr const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acd__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::acd *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_acd" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::acd *)new spot::acd((spot::const_twa_graph_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acd, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_acd(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_acd", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_spot__scc_info, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_new_acd__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_acd__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    PyObject *retobj = _wrap_new_acd__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_acd__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_acd'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acd::acd(spot::scc_info const &,spot::acd_options)\n"
    "    spot::acd::acd(spot::scc_info const &)\n"
    "    spot::acd::acd(spot::const_twa_graph_ptr const &,spot::acd_options)\n"
    "    spot::acd::acd(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_acd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_acd" "', argument " "1"" of type '" "spot::acd *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 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 ;
  PyObject *swig_obj[3] ;
  std::pair< unsigned int,unsigned int > result;
  
  if (!SWIG_Python_UnpackTuple(args, "acd_step", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_step" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_step" "', 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 '" "acd_step" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = ((spot::acd const *)arg1)->step(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::pair< unsigned int,unsigned int > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_state_step(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 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 ;
  PyObject *swig_obj[3] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "acd_state_step", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_state_step" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_state_step" "', 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 '" "acd_state_step" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (unsigned int)((spot::acd const *)arg1)->state_step(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_edges_of_node(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "acd_edges_of_node", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_edges_of_node" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_edges_of_node" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::acd const *)arg1)->edges_of_node(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_node_count(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_node_count" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  {
    try {
      result = (unsigned int)((spot::acd const *)arg1)->node_count();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_node_acceptance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "acd_node_acceptance", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_node_acceptance" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_node_acceptance" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::acd const *)arg1)->node_acceptance(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_node_level(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "acd_node_level", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_node_level" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_node_level" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)((spot::acd const *)arg1)->node_level(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_node_colors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "acd_node_colors", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_node_colors" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_node_colors" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::acc_cond::mark_t *) &((spot::acd const *)arg1)->node_colors(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond__mark_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_is_even__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_is_even" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_is_even" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (bool)((spot::acd const *)arg1)->is_even(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_is_even__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_is_even" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  {
    try {
      result = (bool)((spot::acd const *)arg1)->is_even();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_is_even(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acd_is_even", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_acd_is_even__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_acd_is_even__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acd_is_even'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acd::is_even(unsigned int) const\n"
    "    spot::acd::is_even() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acd_first_branch(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "acd_first_branch", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_first_branch" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_first_branch" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)((spot::acd const *)arg1)->first_branch(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_scc_max_level(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "acd_scc_max_level", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_scc_max_level" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_scc_max_level" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)((spot::acd const *)arg1)->scc_max_level(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_has_rabin_shape(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_has_rabin_shape" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  {
    try {
      result = (bool)((spot::acd const *)arg1)->has_rabin_shape();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_has_streett_shape(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_has_streett_shape" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  {
    try {
      result = (bool)((spot::acd const *)arg1)->has_streett_shape();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_has_parity_shape(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_has_parity_shape" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  {
    try {
      result = (bool)((spot::acd const *)arg1)->has_parity_shape();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_get_aut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::const_twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_get_aut" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  {
    try {
      result = ((spot::acd const *)arg1)->get_aut();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr< const spot::twa_graph > *smartresult = result ? new std::shared_ptr< const spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_dot__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  std::ostream *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_dot" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acd_dot" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acd_dot" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "acd_dot" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      ((spot::acd const *)arg1)->dot(*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_dot__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::acd *arg1 = (spot::acd *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__acd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_dot" "', argument " "1"" of type '" "spot::acd const *""'"); 
  }
  arg1 = reinterpret_cast< spot::acd * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "acd_dot" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "acd_dot" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      ((spot::acd const *)arg1)->dot(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_dot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acd_dot", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_acd_dot__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_acd_dot__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acd_dot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acd::dot(std::ostream &,char const *) const\n"
    "    spot::acd::dot(std::ostream &) const\n");
  return 0;
}


SWIGINTERN PyObject *acd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__acd, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *acd_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_acd_transform__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_transform" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_transform" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::acd_transform((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_transform__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_transform" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::acd_transform((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_transform(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acd_transform", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_acd_transform__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_acd_transform__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acd_transform'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acd_transform(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::acd_transform(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_acd_transform_sbacc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_transform_sbacc" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_transform_sbacc" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "acd_transform_sbacc" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::acd_transform_sbacc((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_transform_sbacc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_transform_sbacc" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "acd_transform_sbacc" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::acd_transform_sbacc((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_transform_sbacc__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "acd_transform_sbacc" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::acd_transform_sbacc((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_acd_transform_sbacc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "acd_transform_sbacc", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_acd_transform_sbacc__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_acd_transform_sbacc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_acd_transform_sbacc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'acd_transform_sbacc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::acd_transform_sbacc(spot::const_twa_graph_ptr const &,bool,bool)\n"
    "    spot::acd_transform_sbacc(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::acd_transform_sbacc(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_dtwa_complement(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dtwa_complement" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::dtwa_complement((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_complement_semidet__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  bool val2 ;
  int ecode2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "complement_semidet" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "complement_semidet" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  {
    try {
      result = spot::complement_semidet((std::shared_ptr< spot::twa_graph const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_complement_semidet__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "complement_semidet" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::complement_semidet((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_complement_semidet(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "complement_semidet", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_complement_semidet__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_complement_semidet__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'complement_semidet'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::complement_semidet(spot::const_twa_graph_ptr const &,bool)\n"
    "    spot::complement_semidet(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_complement__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  spot::output_aborter *arg2 = (spot::output_aborter *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "complement" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__output_aborter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "complement" "', argument " "2"" of type '" "spot::output_aborter const *""'"); 
  }
  arg2 = reinterpret_cast< spot::output_aborter * >(argp2);
  {
    try {
      result = spot::complement((std::shared_ptr< spot::twa_graph const > const &)*arg1,(spot::output_aborter const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_complement__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_graph_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_graph_ptr tempshared1 ;
  spot::twa_graph_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "complement" "', argument " "1"" of type '" "spot::const_twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::complement((std::shared_ptr< spot::twa_graph const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_complement(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "complement", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_complement__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_complement__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'complement'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::complement(spot::const_twa_graph_ptr const &,spot::output_aborter const *)\n"
    "    spot::complement(spot::const_twa_graph_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_fair_kripke_succ_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::fair_kripke_succ_iterator *arg1 = (spot::fair_kripke_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__fair_kripke_succ_iterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_fair_kripke_succ_iterator" "', argument " "1"" of type '" "spot::fair_kripke_succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::fair_kripke_succ_iterator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *fair_kripke_succ_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__fair_kripke_succ_iterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_fair_kripke_state_condition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::fair_kripke *arg1 = (spot::fair_kripke *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::fair_kripke const > tempshared1 ;
  std::shared_ptr< spot::fair_kripke const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bdd result;
  
  if (!SWIG_Python_UnpackTuple(args, "fair_kripke_state_condition", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__fair_kripke_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fair_kripke_state_condition" "', argument " "1"" of type '" "spot::fair_kripke const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::fair_kripke > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::fair_kripke > * >(argp1);
      arg1 = const_cast< spot::fair_kripke * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::fair_kripke > * >(argp1);
      arg1 = const_cast< spot::fair_kripke * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fair_kripke_state_condition" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = ((spot::fair_kripke const *)arg1)->state_condition((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fair_kripke_state_acceptance_mark(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::fair_kripke *arg1 = (spot::fair_kripke *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::fair_kripke const > tempshared1 ;
  std::shared_ptr< spot::fair_kripke const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::acc_cond::mark_t result;
  
  if (!SWIG_Python_UnpackTuple(args, "fair_kripke_state_acceptance_mark", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__fair_kripke_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fair_kripke_state_acceptance_mark" "', argument " "1"" of type '" "spot::fair_kripke const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::fair_kripke > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::fair_kripke > * >(argp1);
      arg1 = const_cast< spot::fair_kripke * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::fair_kripke > * >(argp1);
      arg1 = const_cast< spot::fair_kripke * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fair_kripke_state_acceptance_mark" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = ((spot::fair_kripke const *)arg1)->state_acceptance_mark((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::acc_cond::mark_t(result)), SWIGTYPE_p_spot__acc_cond__mark_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_fair_kripke(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::fair_kripke *arg1 = (spot::fair_kripke *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::fair_kripke > tempshared1 ;
  std::shared_ptr< spot::fair_kripke > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__fair_kripke_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_fair_kripke" "', argument " "1"" of type '" "spot::fair_kripke *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::fair_kripke > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::fair_kripke > * >(argp1);
      arg1 = const_cast< spot::fair_kripke * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::fair_kripke > * >(argp1);
      arg1 = const_cast< spot::fair_kripke * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *fair_kripke_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__fair_kripke_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_kripke_succ_iterator_recycle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_succ_iterator *arg1 = (spot::kripke_succ_iterator *) 0 ;
  bdd *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_succ_iterator_recycle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__kripke_succ_iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_succ_iterator_recycle" "', argument " "1"" of type '" "spot::kripke_succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::kripke_succ_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_succ_iterator_recycle" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_succ_iterator_recycle" "', argument " "2"" of type '" "bdd const &""'"); 
  }
  arg2 = reinterpret_cast< bdd * >(argp2);
  {
    try {
      (arg1)->recycle((bdd const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_kripke_succ_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_succ_iterator *arg1 = (spot::kripke_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__kripke_succ_iterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke_succ_iterator" "', argument " "1"" of type '" "spot::kripke_succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::kripke_succ_iterator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *kripke_succ_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__kripke_succ_iterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_kripke(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke *arg1 = (spot::kripke *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke > tempshared1 ;
  std::shared_ptr< spot::kripke > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke" "', argument " "1"" of type '" "spot::kripke *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke > * >(argp1);
      arg1 = const_cast< spot::kripke * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke > * >(argp1);
      arg1 = const_cast< spot::kripke * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *kripke_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__kripke_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_kripke_graph_state__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  bdd arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::kripke_graph_state *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_kripke_graph_state" "', argument " "1"" of type '" "bdd""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_kripke_graph_state" "', argument " "1"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  {
    try {
      result = (spot::kripke_graph_state *)new spot::kripke_graph_state(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__kripke_graph_state, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_state__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  spot::kripke_graph_state *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (spot::kripke_graph_state *)new spot::kripke_graph_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__kripke_graph_state, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_state__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::kripke_graph_state *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::kripke_graph_state *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_spot__kripke_graph_state,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_kripke_graph_state" "', argument " "1"" of type '" "spot::kripke_graph_state const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_kripke_graph_state" "', argument " "1"" of type '" "spot::kripke_graph_state const &""'"); 
  }
  arg1 = reinterpret_cast< spot::kripke_graph_state * >(argp1);
  {
    try {
      result = (spot::kripke_graph_state *)new spot::kripke_graph_state((spot::kripke_graph_state const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__kripke_graph_state, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_state(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_kripke_graph_state", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_kripke_graph_state__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_bdd, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_kripke_graph_state__SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_kripke_graph_state__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_kripke_graph_state'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::kripke_graph_state::kripke_graph_state(bdd)\n"
    "    spot::kripke_graph_state::kripke_graph_state()\n"
    "    spot::kripke_graph_state::kripke_graph_state(spot::kripke_graph_state const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_kripke_graph_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph_state *arg1 = (spot::kripke_graph_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__kripke_graph_state, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke_graph_state" "', argument " "1"" of type '" "spot::kripke_graph_state *""'"); 
  }
  arg1 = reinterpret_cast< spot::kripke_graph_state * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_clone(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph_state *arg1 = (spot::kripke_graph_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::kripke_graph_state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__kripke_graph_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_clone" "', argument " "1"" of type '" "spot::kripke_graph_state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::kripke_graph_state * >(argp1);
  {
    try {
      result = (spot::kripke_graph_state *)((spot::kripke_graph_state const *)arg1)->clone();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__kripke_graph_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_cond__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::kripke_graph_state *arg1 = (spot::kripke_graph_state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bdd result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__kripke_graph_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_cond" "', argument " "1"" of type '" "spot::kripke_graph_state const *""'"); 
  }
  arg1 = reinterpret_cast< spot::kripke_graph_state * >(argp1);
  {
    try {
      result = ((spot::kripke_graph_state const *)arg1)->cond();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_cond__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::kripke_graph_state *arg1 = (spot::kripke_graph_state *) 0 ;
  bdd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__kripke_graph_state, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_cond" "', argument " "1"" of type '" "spot::kripke_graph_state *""'"); 
  }
  arg1 = reinterpret_cast< spot::kripke_graph_state * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_state_cond" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_cond" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->cond(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_cond(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_state_cond", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_kripke_graph_state_cond__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_state_cond__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_state_cond'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::kripke_graph_state::cond() const\n"
    "    spot::kripke_graph_state::cond(bdd)\n");
  return 0;
}


SWIGINTERN PyObject *kripke_graph_state_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__kripke_graph_state, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *kripke_graph_state_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_kripke_graph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::kripke_graph *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_kripke_graph" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = (spot::kripke_graph *)new spot::kripke_graph((spot::bdd_dict_ptr const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::kripke_graph > *smartresult = result ? new std::shared_ptr<  spot::kripke_graph >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_kripke_graph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph > tempshared1 ;
  std::shared_ptr< spot::kripke_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke_graph" "', argument " "1"" of type '" "spot::kripke_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_num_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph const > tempshared1 ;
  std::shared_ptr< spot::kripke_graph const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_num_states" "', argument " "1"" of type '" "spot::kripke_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::kripke_graph const *)arg1)->num_states();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_num_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph const > tempshared1 ;
  std::shared_ptr< spot::kripke_graph const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_num_edges" "', argument " "1"" of type '" "spot::kripke_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (unsigned int)((spot::kripke_graph const *)arg1)->num_edges();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_set_init_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  spot::kripke_graph::state_num arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph > tempshared1 ;
  std::shared_ptr< spot::kripke_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_set_init_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_set_init_state" "', argument " "1"" of type '" "spot::kripke_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_set_init_state" "', argument " "2"" of type '" "spot::kripke_graph::state_num""'");
  } 
  arg2 = static_cast< spot::kripke_graph::state_num >(val2);
  {
    try {
      (arg1)->set_init_state(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_get_init_state_number(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph const > tempshared1 ;
  std::shared_ptr< spot::kripke_graph const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::kripke_graph::state_num result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_get_init_state_number" "', argument " "1"" of type '" "spot::kripke_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::kripke_graph::state_num)((spot::kripke_graph const *)arg1)->get_init_state_number();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_get_init_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph const > tempshared1 ;
  std::shared_ptr< spot::kripke_graph const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::kripke_graph_state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_get_init_state" "', argument " "1"" of type '" "spot::kripke_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::kripke_graph_state *)((spot::kripke_graph const *)arg1)->get_init_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__kripke_graph_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_succ_iter(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph const > tempshared1 ;
  std::shared_ptr< spot::kripke_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::kripke_graph_succ_iterator< spot::kripke_graph::graph_t > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_succ_iter", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_succ_iter" "', argument " "1"" of type '" "spot::kripke_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_succ_iter" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (spot::kripke_graph_succ_iterator< spot::kripke_graph::graph_t > *)((spot::kripke_graph const *)arg1)->succ_iter((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__kripke_graph_succ_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_number(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph const > tempshared1 ;
  std::shared_ptr< spot::kripke_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::kripke_graph::state_num result;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_number", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_number" "', argument " "1"" of type '" "spot::kripke_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_state_number" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (spot::kripke_graph::state_num)((spot::kripke_graph const *)arg1)->state_number((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_from_number__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  spot::kripke_graph::state_num arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph const > tempshared1 ;
  std::shared_ptr< spot::kripke_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::kripke_graph_state *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_from_number" "', argument " "1"" of type '" "spot::kripke_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_from_number" "', argument " "2"" of type '" "spot::kripke_graph::state_num""'");
  } 
  arg2 = static_cast< spot::kripke_graph::state_num >(val2);
  {
    try {
      result = (spot::kripke_graph_state *)((spot::kripke_graph const *)arg1)->state_from_number(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__kripke_graph_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_from_number__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  spot::kripke_graph::state_num arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph > tempshared1 ;
  std::shared_ptr< spot::kripke_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::kripke_graph_state *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_from_number" "', argument " "1"" of type '" "spot::kripke_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_from_number" "', argument " "2"" of type '" "spot::kripke_graph::state_num""'");
  } 
  arg2 = static_cast< spot::kripke_graph::state_num >(val2);
  {
    try {
      result = (spot::kripke_graph_state *)(arg1)->state_from_number(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__kripke_graph_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_from_number(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_state_from_number", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_state_from_number__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_state_from_number__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_state_from_number'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::kripke_graph::state_from_number(spot::kripke_graph::state_num) const\n"
    "    spot::kripke_graph::state_from_number(spot::kripke_graph::state_num)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_kripke_graph_format_state__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph const > tempshared1 ;
  std::shared_ptr< spot::kripke_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_format_state" "', argument " "1"" of type '" "spot::kripke_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_format_state" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::kripke_graph const *)arg1)->format_state(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_format_state__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph const > tempshared1 ;
  std::shared_ptr< spot::kripke_graph const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::string result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_format_state" "', argument " "1"" of type '" "spot::kripke_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_format_state" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = ((spot::kripke_graph const *)arg1)->format_state((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_format_state(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_format_state", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_spot__state, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_kripke_graph_format_state__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_format_state__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_format_state'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::kripke_graph::format_state(unsigned int) const\n"
    "    spot::kripke_graph::format_state(spot::state const *) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph > tempshared1 ;
  std::shared_ptr< spot::kripke_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::kripke_graph::edge_storage_t *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_storage" "', argument " "1"" of type '" "spot::kripke_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_edge_storage" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::kripke_graph::edge_storage_t *) &(arg1)->edge_storage(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph const > tempshared1 ;
  std::shared_ptr< spot::kripke_graph const > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::kripke_graph::edge_storage_t result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_storage" "', argument " "1"" of type '" "spot::kripke_graph const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_edge_storage" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = ((spot::kripke_graph const *)arg1)->edge_storage(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::kripke_graph::edge_storage_t(result)), SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_edge_storage", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_edge_storage__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_edge_storage__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_edge_storage'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::kripke_graph::edge_storage(unsigned int)\n"
    "    spot::kripke_graph::edge_storage(unsigned int) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_kripke_graph_new_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  bdd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph > tempshared1 ;
  std::shared_ptr< spot::kripke_graph > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_new_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_new_state" "', argument " "1"" of type '" "spot::kripke_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_new_state" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_new_state" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->new_state(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_new_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  unsigned int arg2 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph > tempshared1 ;
  std::shared_ptr< spot::kripke_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_new_states", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_new_states" "', argument " "1"" of type '" "spot::kripke_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_new_states" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kripke_graph_new_states" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_new_states" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (unsigned int)(arg1)->new_states(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_new_edge(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph > tempshared1 ;
  std::shared_ptr< spot::kripke_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_new_edge", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_new_edge" "', argument " "1"" of type '" "spot::kripke_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_new_edge" "', 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 '" "kripke_graph_new_edge" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (unsigned int)(arg1)->new_edge(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_states(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph > tempshared1 ;
  std::shared_ptr< spot::kripke_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::kripke_graph::state_vector *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_states" "', argument " "1"" of type '" "spot::kripke_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::kripke_graph::state_vector *) &(arg1)->states();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edges(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph > tempshared1 ;
  std::shared_ptr< spot::kripke_graph > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edges" "', argument " "1"" of type '" "spot::kripke_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    resultobj = SWIG_NewPointerObj(new spot::internal::all_trans< spot::kripke_graph::graph_t >((arg1)->edges()), SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t,
      SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_out(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::kripke_graph *arg1 = (spot::kripke_graph *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::kripke_graph > tempshared1 ;
  std::shared_ptr< spot::kripke_graph > *smartarg1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SwigValueWrapper< spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > > result;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_out", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_out" "', argument " "1"" of type '" "spot::kripke_graph *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::kripke_graph > * >(argp1);
      arg1 = const_cast< spot::kripke_graph * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_out" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (arg1)->out(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::state_out< spot::kripke_graph::graph_t >(result)), SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *kripke_graph_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *kripke_graph_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_make_kripke_graph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::bdd_dict_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::bdd_dict_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::kripke_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_kripke_graph" "', argument " "1"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::make_kripke_graph((std::shared_ptr< spot::bdd_dict > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::kripke_graph > *smartresult = result ? new std::shared_ptr<  spot::kripke_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_state_out(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::digraph< spot::kripke_graph_state,void > *arg1 = (spot::digraph< spot::kripke_graph_state,void > *) 0 ;
  SwigValueWrapper< spot::digraph< spot::kripke_graph_state,void >::edge > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_kripke_graph_state_out", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__digraphT_spot__kripke_graph_state_void_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_kripke_graph_state_out" "', argument " "1"" of type '" "spot::digraph< spot::kripke_graph_state,void > *""'"); 
  }
  arg1 = reinterpret_cast< spot::digraph< spot::kripke_graph_state,void > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__digraphT_spot__kripke_graph_state_void_t__edge,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_kripke_graph_state_out" "', argument " "2"" of type '" "spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >::edge""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_kripke_graph_state_out" "', argument " "2"" of type '" "spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >::edge""'");
    } else {
      spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >::edge * temp = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >::edge * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *)new spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_out_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *arg1 = (spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::edge_iterator< spot::digraph< spot::kripke_graph_state,void > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_out_begin" "', argument " "1"" of type '" "spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > * >(argp1);
  {
    try {
      result = ((spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > const *)arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::edge_iterator< spot::digraph< spot::kripke_graph_state,void > >(result)), SWIGTYPE_p_spot__internal__edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_out_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *arg1 = (spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::edge_iterator< spot::digraph< spot::kripke_graph_state,void > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_out_end" "', argument " "1"" of type '" "spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > * >(argp1);
  {
    try {
      result = ((spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > const *)arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::edge_iterator< spot::digraph< spot::kripke_graph_state,void > >(result)), SWIGTYPE_p_spot__internal__edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_out_recycle(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *arg1 = (spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *) 0 ;
  SwigValueWrapper< spot::digraph< spot::kripke_graph_state,void >::edge > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_out_recycle", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_out_recycle" "', argument " "1"" of type '" "spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__digraphT_spot__kripke_graph_state_void_t__edge,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_state_out_recycle" "', argument " "2"" of type '" "spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >::edge""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_out_recycle" "', argument " "2"" of type '" "spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >::edge""'");
    } else {
      spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >::edge * temp = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >::edge * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      (arg1)->recycle(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_out___iter__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *arg1 = (spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_out___iter__" "', argument " "1"" of type '" "spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)spot_internal_state_out_Sl_spot_digraph_Sl_spot_kripke_graph_state_Sc_void_Sg__Sg____iter__(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_kripke_graph_state_out(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *arg1 = (spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke_graph_state_out" "', argument " "1"" of type '" "spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *kripke_graph_state_out_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *kripke_graph_state_out_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_kripke_graph_all_trans(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > >::tv_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__conditionalT_std__is_constT_spot__digraphT_spot__kripke_graph_state_void_t_t__value_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_const_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_t__type,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_kripke_graph_all_trans" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > >::tv_t &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_kripke_graph_all_trans" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > >::tv_t &""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > >::tv_t * >(argp1);
  {
    try {
      result = (spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *)new spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > >(*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_all_trans_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *arg1 = (spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::all_edge_iterator< spot::digraph< spot::kripke_graph_state,void > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_all_trans_begin" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > * >(argp1);
  {
    try {
      result = ((spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > const *)arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > >::iter_t(result)), SWIGTYPE_p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_all_trans_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *arg1 = (spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< spot::internal::all_edge_iterator< spot::digraph< spot::kripke_graph_state,void > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_all_trans_end" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > * >(argp1);
  {
    try {
      result = ((spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > const *)arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > >::iter_t(result)), SWIGTYPE_p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_all_trans___iter__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *arg1 = (spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_all_trans___iter__" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)spot_internal_all_trans_Sl_spot_digraph_Sl_spot_kripke_graph_state_Sc_void_Sg__Sg____iter__(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_kripke_graph_all_trans(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *arg1 = (spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke_graph_all_trans" "', argument " "1"" of type '" "spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *kripke_graph_all_trans_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *kripke_graph_all_trans_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_kripke_graph_edge_boxed_data_data__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< void,true > *arg1 = (spot::internal::boxed_label< void,true > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::tuple< > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__boxed_labelT_void_true_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_boxed_data_data" "', argument " "1"" of type '" "spot::internal::boxed_label< void,true > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::boxed_label< void,true > * >(argp1);
  {
    try {
      result = (std::tuple< > *) &(arg1)->data();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__tupleT_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_boxed_data_data__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< void,true > *arg1 = (spot::internal::boxed_label< void,true > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::tuple< > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__boxed_labelT_void_true_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_boxed_data_data" "', argument " "1"" of type '" "spot::internal::boxed_label< void,true > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::boxed_label< void,true > * >(argp1);
  {
    try {
      result = (std::tuple< > *) &((spot::internal::boxed_label< void,true > const *)arg1)->data();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__tupleT_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_boxed_data_data(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_edge_boxed_data_data", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_kripke_graph_edge_boxed_data_data__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_kripke_graph_edge_boxed_data_data__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_edge_boxed_data_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::internal::boxed_label< void,true >::data()\n"
    "    spot::internal::boxed_label< void,true >::data() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_edge_boxed_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< void,true > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_kripke_graph_edge_boxed_data", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::internal::boxed_label< void,true > *)new spot::internal::boxed_label< void,true >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__boxed_labelT_void_true_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_kripke_graph_edge_boxed_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< void,true > *arg1 = (spot::internal::boxed_label< void,true > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__boxed_labelT_void_true_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke_graph_edge_boxed_data" "', argument " "1"" of type '" "spot::internal::boxed_label< void,true > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::boxed_label< void,true > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *kripke_graph_edge_boxed_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__boxed_labelT_void_true_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *kripke_graph_edge_boxed_data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage_dst_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_edge_storage_dst_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_storage_dst_set" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_edge_storage_dst_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->dst = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage_dst_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_storage_dst_get" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp1);
  result = (unsigned int) ((arg1)->dst);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage_next_succ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_edge_storage_next_succ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_storage_next_succ_set" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_edge_storage_next_succ_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->next_succ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage_next_succ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_storage_next_succ_get" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp1);
  result = (unsigned int) ((arg1)->next_succ);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage_src_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_edge_storage_src_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_storage_src_set" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_edge_storage_src_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->src = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage_src_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_storage_src_get" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp1);
  result = (unsigned int) ((arg1)->src);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_edge_storage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_kripke_graph_edge_storage", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *)new spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage___lt__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) 0 ;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_edge_storage___lt__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_storage___lt__" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_edge_storage___lt__" "', argument " "2"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_edge_storage___lt__" "', argument " "2"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > const &""'"); 
  }
  arg2 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp2);
  {
    try {
      result = (bool)((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > const *)arg1)->operator <((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_kripke_graph_edge_storage___eq__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) 0 ;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_edge_storage___eq__", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_edge_storage___eq__" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_edge_storage___eq__" "', argument " "2"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_edge_storage___eq__" "', argument " "2"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > const &""'"); 
  }
  arg2 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp2);
  {
    try {
      result = (bool)((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > const *)arg1)->operator ==((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  PyErr_Clear();
  Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_delete_kripke_graph_edge_storage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *arg1 = (spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke_graph_edge_storage" "', argument " "1"" of type '" "spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *kripke_graph_edge_storage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *kripke_graph_edge_storage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_kripke_graph_state_boxed_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< spot::kripke_graph_state,false > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_kripke_graph_state_boxed_data", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::internal::boxed_label< spot::kripke_graph_state,false > *)new spot::internal::boxed_label< spot::kripke_graph_state,false >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_boxed_data_data__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< spot::kripke_graph_state,false > *arg1 = (spot::internal::boxed_label< spot::kripke_graph_state,false > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::kripke_graph_state *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_boxed_data_data" "', argument " "1"" of type '" "spot::internal::boxed_label< spot::kripke_graph_state,false > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::boxed_label< spot::kripke_graph_state,false > * >(argp1);
  {
    try {
      result = (spot::kripke_graph_state *) &(arg1)->data();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__kripke_graph_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_boxed_data_data__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< spot::kripke_graph_state,false > *arg1 = (spot::internal::boxed_label< spot::kripke_graph_state,false > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::kripke_graph_state *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_boxed_data_data" "', argument " "1"" of type '" "spot::internal::boxed_label< spot::kripke_graph_state,false > const *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::boxed_label< spot::kripke_graph_state,false > * >(argp1);
  {
    try {
      result = (spot::kripke_graph_state *) &((spot::internal::boxed_label< spot::kripke_graph_state,false > const *)arg1)->data();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__kripke_graph_state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_boxed_data_data(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_state_boxed_data_data", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_kripke_graph_state_boxed_data_data__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_kripke_graph_state_boxed_data_data__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_state_boxed_data_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::internal::boxed_label< spot::kripke_graph_state,false >::data()\n"
    "    spot::internal::boxed_label< spot::kripke_graph_state,false >::data() const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_kripke_graph_state_boxed_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::boxed_label< spot::kripke_graph_state,false > *arg1 = (spot::internal::boxed_label< spot::kripke_graph_state,false > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke_graph_state_boxed_data" "', argument " "1"" of type '" "spot::internal::boxed_label< spot::kripke_graph_state,false > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::boxed_label< spot::kripke_graph_state,false > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *kripke_graph_state_boxed_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *kripke_graph_state_boxed_data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_kripke_graph_state_storage_succ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *arg1 = (spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_storage_succ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_storage_succ_set" "', argument " "1"" of type '" "spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_storage_succ_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->succ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_storage_succ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *arg1 = (spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_storage_succ_get" "', argument " "1"" of type '" "spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > * >(argp1);
  result = (unsigned int) ((arg1)->succ);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_storage_succ_tail_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *arg1 = (spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_storage_succ_tail_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_storage_succ_tail_set" "', argument " "1"" of type '" "spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_storage_succ_tail_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->succ_tail = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_storage_succ_tail_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *arg1 = (spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_storage_succ_tail_get" "', argument " "1"" of type '" "spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > * >(argp1);
  result = (unsigned int) ((arg1)->succ_tail);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_state_storage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_kripke_graph_state_storage", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *)new spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_kripke_graph_state_storage(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *arg1 = (spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke_graph_state_storage" "', argument " "1"" of type '" "spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *""'"); 
  }
  arg1 = reinterpret_cast< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *kripke_graph_state_storage_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *kripke_graph_state_storage_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  PyObject **arg2 = (PyObject **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_iterator" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__iterator(arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___nonzero__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____nonzero__((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___bool__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____bool__((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___len__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____len__((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___getslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector___getslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___getslice__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector___getslice__" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kripke_graph_state_vector___getslice__" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *)std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___setslice__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector___setslice__" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kripke_graph_state_vector___setslice__" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg3 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___setslice__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector___setslice__" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kripke_graph_state_vector___setslice__" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val3);
  {
    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *ptr = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "kripke_graph_state_vector___setslice__" "', argument " "4"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_vector___setslice__" "', argument " "4"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_kripke_graph_state_vector___setslice____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_kripke_graph_state_vector___setslice____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_state_vector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::__setslice__(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type)\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::__setslice__(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___delslice__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector___delslice__", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___delslice__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector___delslice__" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kripke_graph_state_vector___delslice__" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___delitem__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector___delitem__" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___getitem__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "kripke_graph_state_vector___getitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *)std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___setitem__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "kripke_graph_state_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *ptr = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kripke_graph_state_vector___setitem__" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_vector___setitem__" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > 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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___setitem__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "kripke_graph_state_vector___setitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  PySliceObject *arg2 = (PySliceObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___delitem__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "kripke_graph_state_vector___delitem__" "', argument " "2"" of type '" "PySliceObject *""'");
    }
    arg2 = (PySliceObject *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__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 (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_kripke_graph_state_vector___delitem____SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_state_vector___delitem____SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_state_vector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::__delitem__(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type)\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::__delitem__(PySliceObject *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___getitem__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector___getitem__" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *) &std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____getitem____SWIG_1((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_1;
    return _wrap_kripke_graph_state_vector___getitem____SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_state_vector___getitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_state_vector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::__getitem__(PySliceObject *)\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::__getitem__(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type arg2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector___setitem__" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector___setitem__" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kripke_graph_state_vector___setitem__" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_vector___setitem__" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_state_vector___setitem____SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        _v = PySlice_Check(argv[1]);
      }
    }
    if (!_v) goto check_2;
    {
      int res = swig::asptr(argv[2], (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > >**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_kripke_graph_state_vector___setitem____SWIG_0(self, argc, argv);
  }
check_2:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_kripke_graph_state_vector___setitem____SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_state_vector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::__setitem__(PySliceObject *,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > const &)\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::__setitem__(PySliceObject *)\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::__setitem__(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::difference_type,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_pop" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type(result)), SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_append(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector_append", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_append" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_state_vector_append" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_vector_append" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__append(arg1,(spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_state_vector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *result = 0 ;
  
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *)new std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_state_vector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *ptr = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_kripke_graph_state_vector" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_kripke_graph_state_vector" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *)new std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_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_kripke_graph_state_vector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_empty" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *)arg1)->empty();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_size" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = ((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *)arg1)->size();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_swap(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector_swap", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_swap" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_state_vector_swap" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_vector_swap" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_begin" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_end" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_rbegin" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::reverse_iterator result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_rend" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_clear" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      (arg1)->clear();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_get_allocator" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = ((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *)arg1)->get_allocator();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_state_vector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *result = 0 ;
  
  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_kripke_graph_state_vector" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type >(val1);
  {
    try {
      result = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *)new std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_pop_back" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_resize" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector_resize" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type >(val2);
  {
    try {
      (arg1)->resize(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_erase" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(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 '" "kripke_graph_state_vector_erase" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "kripke_graph_state_vector_erase" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator arg2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_erase" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(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 '" "kripke_graph_state_vector_erase" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "kripke_graph_state_vector_erase" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::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 '" "kripke_graph_state_vector_erase" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "kripke_graph_state_vector_erase" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_state_vector_erase__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_kripke_graph_state_vector_erase__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_state_vector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::erase(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator)\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::erase(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_state_vector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type arg1 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *result = 0 ;
  
  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_kripke_graph_state_vector" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_kripke_graph_state_vector" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_kripke_graph_state_vector" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type * >(argp2);
  {
    try {
      result = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *)new std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >(arg1,(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_kripke_graph_state_vector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_kripke_graph_state_vector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    PyObject *retobj = _wrap_new_kripke_graph_state_vector__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_size_t(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    return _wrap_new_kripke_graph_state_vector__SWIG_2(self, argc, argv);
  }
check_2:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_new_kripke_graph_state_vector__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_kripke_graph_state_vector__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_kripke_graph_state_vector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::vector()\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::vector(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const &)\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::vector(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type)\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::vector(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_push_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector_push_back", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_push_back" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "kripke_graph_state_vector_push_back" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_vector_push_back" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_front" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *) &((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *)arg1)->front();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_back" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *) &((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *)arg1)->back();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, 0 |  0 );
  (void)swig::container_owner<swig::traits<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type>::category>::back_reference(resultobj, swig_obj[0]);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_assign(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type arg2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector_assign", 3, 3, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_assign" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector_assign" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kripke_graph_state_vector_assign" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_vector_assign" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(arg2,(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type arg2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_resize" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector_resize" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kripke_graph_state_vector_resize" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_vector_resize" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(arg2,(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_kripke_graph_state_vector_resize__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_kripke_graph_state_vector_resize__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_state_vector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::resize(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type)\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::resize(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator arg2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_insert" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(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 '" "kripke_graph_state_vector_insert" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "kripke_graph_state_vector_insert" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "kripke_graph_state_vector_insert" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_vector_insert" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > const &)*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator arg2 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type arg3 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::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 ;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_insert" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(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 '" "kripke_graph_state_vector_insert" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "kripke_graph_state_vector_insert" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kripke_graph_state_vector_insert" "', argument " "3"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "kripke_graph_state_vector_insert" "', argument " "4"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "kripke_graph_state_vector_insert" "', argument " "4"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_spot_internal_distate_storage_Sl_unsigned_SS_int_Sc_spot_internal_boxed_label_Sl_spot_kripke_graph_state_Sc_false_Sg__Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > const &)*arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    PyObject *retobj = _wrap_kripke_graph_state_vector_insert__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_kripke_graph_state_vector_insert__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'kripke_graph_state_vector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::insert(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &)\n"
    "    std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::insert(std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::iterator,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type,std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_reserve(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "kripke_graph_state_vector_reserve", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_reserve" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "kripke_graph_state_vector_reserve" "', argument " "2"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kripke_graph_state_vector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::size_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "kripke_graph_state_vector_capacity" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      result = ((std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > const *)arg1)->capacity();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_kripke_graph_state_vector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *arg1 = (std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_kripke_graph_state_vector" "', argument " "1"" of type '" "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *kripke_graph_state_vector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *kripke_graph_state_vector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_parse_aut_error_list___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parse_aut_error_list *arg1 = (spot::parse_aut_error_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parse_aut_error_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_aut_error_list___nonzero__" "', argument " "1"" of type '" "spot::parse_aut_error_list *""'"); 
  }
  arg1 = reinterpret_cast< spot::parse_aut_error_list * >(argp1);
  {
    try {
      result = (bool)spot_parse_aut_error_list___nonzero__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_aut_error_list___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parse_aut_error_list *arg1 = (spot::parse_aut_error_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parse_aut_error_list, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_aut_error_list___bool__" "', argument " "1"" of type '" "spot::parse_aut_error_list *""'"); 
  }
  arg1 = reinterpret_cast< spot::parse_aut_error_list * >(argp1);
  {
    try {
      result = (bool)spot_parse_aut_error_list___bool__(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_parse_aut_error_list(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parse_aut_error_list *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_parse_aut_error_list", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::parse_aut_error_list *)new spot::parse_aut_error_list();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__parse_aut_error_list, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_parse_aut_error_list(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parse_aut_error_list *arg1 = (spot::parse_aut_error_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__parse_aut_error_list, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_parse_aut_error_list" "', argument " "1"" of type '" "spot::parse_aut_error_list *""'"); 
  }
  arg1 = reinterpret_cast< spot::parse_aut_error_list * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *parse_aut_error_list_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__parse_aut_error_list, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *parse_aut_error_list_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_parsed_aut_aut_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  spot::twa_graph_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::twa_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_aut_aut_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_aut_set" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parsed_aut_aut_set" "', argument " "2"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::twa_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::twa_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  if (arg1) (arg1)->aut = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_aut_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_aut_get" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::twa_graph_ptr *) & ((arg1)->aut);
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = *result ? new std::shared_ptr<  spot::twa_graph >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_ks_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  spot::kripke_graph_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::kripke_graph_ptr tempshared2 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_aut_ks_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_ks_set" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parsed_aut_ks_set" "', argument " "2"" of type '" "spot::kripke_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::kripke_graph_ptr * >(argp2);
      delete reinterpret_cast< spot::kripke_graph_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::kripke_graph_ptr * >(argp2) : &tempshared2;
    }
  }
  if (arg1) (arg1)->ks = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_ks_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::kripke_graph_ptr *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_ks_get" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::kripke_graph_ptr *) & ((arg1)->ks);
  {
    std::shared_ptr<  spot::kripke_graph > *smartresult = *result ? new std::shared_ptr<  spot::kripke_graph >(*result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__kripke_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_aborted_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_aut_aborted_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_aborted_set" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "parsed_aut_aborted_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->aborted = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_aborted_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_aborted_get" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (bool) ((arg1)->aborted);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_loc_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  spot::location arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_aut_loc_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_loc_set" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__location,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parsed_aut_loc_set" "', argument " "2"" of type '" "spot::location""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parsed_aut_loc_set" "', argument " "2"" of type '" "spot::location""'");
    } else {
      spot::location * temp = reinterpret_cast< spot::location * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  if (arg1) (arg1)->loc = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_loc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::location result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_loc_get" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result =  ((arg1)->loc);
  resultobj = SWIG_NewPointerObj((new spot::location(result)), SWIGTYPE_p_spot__location, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  spot::parsed_aut_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_aut_type_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_type_set" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "parsed_aut_type_set" "', argument " "2"" of type '" "spot::parsed_aut_type""'");
  } 
  arg2 = static_cast< spot::parsed_aut_type >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::parsed_aut_type result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_type_get" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::parsed_aut_type) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_filename_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_aut_filename_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_filename_set" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    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 '" "parsed_aut_filename_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parsed_aut_filename_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->filename = *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_parsed_aut_filename_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_filename_get" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (std::string *) & ((arg1)->filename);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_errors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  spot::parse_aut_error_list *arg2 = (spot::parse_aut_error_list *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_aut_errors_set", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_errors_set" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__parse_aut_error_list, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parsed_aut_errors_set" "', argument " "2"" of type '" "spot::parse_aut_error_list *""'"); 
  }
  arg2 = reinterpret_cast< spot::parse_aut_error_list * >(argp2);
  if (arg1) (arg1)->errors = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_errors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::parse_aut_error_list *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_errors_get" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  result = (spot::parse_aut_error_list *)& ((arg1)->errors);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__parse_aut_error_list, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_parsed_aut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  PyObject *swig_obj[1] ;
  spot::parsed_aut *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_parsed_aut" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_parsed_aut" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (spot::parsed_aut *)new spot::parsed_aut((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::parsed_aut > *smartresult = result ? new std::shared_ptr<  spot::parsed_aut >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parsed_aut_format_errors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "parsed_aut_format_errors", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parsed_aut_format_errors" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parsed_aut_format_errors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parsed_aut_format_errors" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (bool)(arg1)->format_errors(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_parsed_aut(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::parsed_aut *arg1 = (spot::parsed_aut *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::parsed_aut > tempshared1 ;
  std::shared_ptr< spot::parsed_aut > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_parsed_aut" "', argument " "1"" of type '" "spot::parsed_aut *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::parsed_aut > * >(argp1);
      arg1 = const_cast< spot::parsed_aut * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *parsed_aut_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *parsed_aut_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_automaton_parser_options_ignore_abort_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "automaton_parser_options_ignore_abort_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_parser_options_ignore_abort_set" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "automaton_parser_options_ignore_abort_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->ignore_abort = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_parser_options_ignore_abort_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_parser_options_ignore_abort_get" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  result = (bool) ((arg1)->ignore_abort);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_parser_options_debug_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "automaton_parser_options_debug_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_parser_options_debug_set" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "automaton_parser_options_debug_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->debug = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_parser_options_debug_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_parser_options_debug_get" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  result = (bool) ((arg1)->debug);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_parser_options_trust_hoa_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "automaton_parser_options_trust_hoa_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_parser_options_trust_hoa_set" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "automaton_parser_options_trust_hoa_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->trust_hoa = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_parser_options_trust_hoa_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_parser_options_trust_hoa_get" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  result = (bool) ((arg1)->trust_hoa);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_parser_options_raise_errors_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "automaton_parser_options_raise_errors_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_parser_options_raise_errors_set" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "automaton_parser_options_raise_errors_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->raise_errors = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_parser_options_raise_errors_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_parser_options_raise_errors_get" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  result = (bool) ((arg1)->raise_errors);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_parser_options_want_kripke_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "automaton_parser_options_want_kripke_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_parser_options_want_kripke_set" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "automaton_parser_options_want_kripke_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->want_kripke = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_parser_options_want_kripke_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_parser_options_want_kripke_get" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  result = (bool) ((arg1)->want_kripke);
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_automaton_parser_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_automaton_parser_options", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::automaton_parser_options *)new spot::automaton_parser_options();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__automaton_parser_options, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_automaton_parser_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_parser_options *arg1 = (spot::automaton_parser_options *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_parser_options, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_automaton_parser_options" "', argument " "1"" of type '" "spot::automaton_parser_options *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_parser_options * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *automaton_parser_options_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__automaton_parser_options, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *automaton_parser_options_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_automaton_stream_parser__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::automaton_parser_options arg2 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  spot::automaton_stream_parser *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_automaton_stream_parser" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_automaton_stream_parser" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_spot__automaton_parser_options,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_automaton_stream_parser" "', argument " "2"" of type '" "spot::automaton_parser_options""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_automaton_stream_parser" "', argument " "2"" of type '" "spot::automaton_parser_options""'");
    } else {
      spot::automaton_parser_options * temp = reinterpret_cast< spot::automaton_parser_options * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::automaton_stream_parser *)new spot::automaton_stream_parser((std::string const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__automaton_stream_parser, 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_automaton_stream_parser__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  spot::automaton_stream_parser *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_automaton_stream_parser" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_automaton_stream_parser" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (spot::automaton_stream_parser *)new spot::automaton_stream_parser((std::string const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__automaton_stream_parser, 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_automaton_stream_parser__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  spot::automaton_parser_options arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  spot::automaton_stream_parser *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_automaton_stream_parser" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_automaton_stream_parser" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_automaton_stream_parser" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__automaton_parser_options,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_automaton_stream_parser" "', argument " "3"" of type '" "spot::automaton_parser_options""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_automaton_stream_parser" "', argument " "3"" of type '" "spot::automaton_parser_options""'");
    } else {
      spot::automaton_parser_options * temp = reinterpret_cast< spot::automaton_parser_options * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (spot::automaton_stream_parser *)new spot::automaton_stream_parser(arg1,(std::string const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__automaton_stream_parser, 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_automaton_stream_parser__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  int arg1 ;
  std::string *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  spot::automaton_stream_parser *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_automaton_stream_parser" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(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_automaton_stream_parser" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_automaton_stream_parser" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (spot::automaton_stream_parser *)new spot::automaton_stream_parser(arg1,(std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__automaton_stream_parser, 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_automaton_stream_parser__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  std::string *arg2 = 0 ;
  spot::automaton_parser_options arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  spot::automaton_stream_parser *result = 0 ;
  
  if ((nobjs < 3) || (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_automaton_stream_parser" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    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_automaton_stream_parser" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_automaton_stream_parser" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__automaton_parser_options,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_automaton_stream_parser" "', argument " "3"" of type '" "spot::automaton_parser_options""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_automaton_stream_parser" "', argument " "3"" of type '" "spot::automaton_parser_options""'");
    } else {
      spot::automaton_parser_options * temp = reinterpret_cast< spot::automaton_parser_options * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (spot::automaton_stream_parser *)new spot::automaton_stream_parser((char const *)arg1,(std::string const &)*arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__automaton_stream_parser, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_automaton_stream_parser__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  std::string *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  spot::automaton_stream_parser *result = 0 ;
  
  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 '" "new_automaton_stream_parser" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    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_automaton_stream_parser" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_automaton_stream_parser" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (spot::automaton_stream_parser *)new spot::automaton_stream_parser((char const *)arg1,(std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__automaton_stream_parser, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_automaton_stream_parser(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_automaton_stream_parser", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_automaton_stream_parser__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_2;
    {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_new_automaton_stream_parser__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_spot__automaton_parser_options, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_3;
    return _wrap_new_automaton_stream_parser__SWIG_0(self, argc, argv);
  }
check_3:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_new_automaton_stream_parser__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      {
        int res = SWIG_AsVal_int(argv[0], NULL);
        _v = SWIG_CheckState(res);
      }
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_new_automaton_stream_parser__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_new_automaton_stream_parser__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_automaton_stream_parser'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::automaton_stream_parser::automaton_stream_parser(std::string const &,spot::automaton_parser_options)\n"
    "    spot::automaton_stream_parser::automaton_stream_parser(std::string const &)\n"
    "    spot::automaton_stream_parser::automaton_stream_parser(int,std::string const &,spot::automaton_parser_options)\n"
    "    spot::automaton_stream_parser::automaton_stream_parser(int,std::string const &)\n"
    "    spot::automaton_stream_parser::automaton_stream_parser(char const *,std::string const &,spot::automaton_parser_options)\n"
    "    spot::automaton_stream_parser::automaton_stream_parser(char const *,std::string const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_automaton_stream_parser(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::automaton_stream_parser *arg1 = (spot::automaton_stream_parser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_stream_parser, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_automaton_stream_parser" "', argument " "1"" of type '" "spot::automaton_stream_parser *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_stream_parser * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_stream_parser_parse__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::automaton_stream_parser *arg1 = (spot::automaton_stream_parser *) 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  spot::environment *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::parsed_aut_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_stream_parser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_stream_parser_parse" "', argument " "1"" of type '" "spot::automaton_stream_parser *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_stream_parser * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "automaton_stream_parser_parse" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "automaton_stream_parser_parse" "', argument " "3"" of type '" "spot::environment &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "automaton_stream_parser_parse" "', argument " "3"" of type '" "spot::environment &""'"); 
  }
  arg3 = reinterpret_cast< spot::environment * >(argp3);
  {
    try {
      result = (arg1)->parse((spot::bdd_dict_ptr const &)*arg2,*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::parsed_aut > *smartresult = result ? new std::shared_ptr<  spot::parsed_aut >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_stream_parser_parse__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::automaton_stream_parser *arg1 = (spot::automaton_stream_parser *) 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  spot::parsed_aut_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__automaton_stream_parser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "automaton_stream_parser_parse" "', argument " "1"" of type '" "spot::automaton_stream_parser *""'"); 
  }
  arg1 = reinterpret_cast< spot::automaton_stream_parser * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "automaton_stream_parser_parse" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (arg1)->parse((spot::bdd_dict_ptr const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::parsed_aut > *smartresult = result ? new std::shared_ptr<  spot::parsed_aut >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_automaton_stream_parser_parse(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "automaton_stream_parser_parse", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_automaton_stream_parser_parse__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_automaton_stream_parser_parse__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'automaton_stream_parser_parse'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::automaton_stream_parser::parse(spot::bdd_dict_ptr const &,spot::environment &)\n"
    "    spot::automaton_stream_parser::parse(spot::bdd_dict_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *automaton_stream_parser_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__automaton_stream_parser, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *automaton_stream_parser_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_parse_aut__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  spot::environment *arg3 = 0 ;
  spot::automaton_parser_options arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  spot::parsed_aut_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_aut" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_aut" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_aut" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "parse_aut" "', argument " "3"" of type '" "spot::environment &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_aut" "', argument " "3"" of type '" "spot::environment &""'"); 
  }
  arg3 = reinterpret_cast< spot::environment * >(argp3);
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_spot__automaton_parser_options,  0  | 0);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "parse_aut" "', argument " "4"" of type '" "spot::automaton_parser_options""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_aut" "', argument " "4"" of type '" "spot::automaton_parser_options""'");
    } else {
      spot::automaton_parser_options * temp = reinterpret_cast< spot::automaton_parser_options * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  {
    try {
      result = spot::parse_aut((std::string const &)*arg1,(std::shared_ptr< spot::bdd_dict > const &)*arg2,*arg3,SWIG_STD_MOVE(arg4));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::parsed_aut > *smartresult = result ? new std::shared_ptr<  spot::parsed_aut >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_aut__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  spot::environment *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::parsed_aut_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_aut" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_aut" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_aut" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_spot__environment,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "parse_aut" "', argument " "3"" of type '" "spot::environment &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_aut" "', argument " "3"" of type '" "spot::environment &""'"); 
  }
  arg3 = reinterpret_cast< spot::environment * >(argp3);
  {
    try {
      result = spot::parse_aut((std::string const &)*arg1,(std::shared_ptr< spot::bdd_dict > const &)*arg2,*arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::parsed_aut > *smartresult = result ? new std::shared_ptr<  spot::parsed_aut >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_aut__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  spot::bdd_dict_ptr *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  spot::bdd_dict_ptr tempshared2 ;
  spot::parsed_aut_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_aut" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "parse_aut" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_aut" "', argument " "2"" of type '" "spot::bdd_dict_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      delete reinterpret_cast< spot::bdd_dict_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::bdd_dict_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = spot::parse_aut((std::string const &)*arg1,(std::shared_ptr< spot::bdd_dict > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::parsed_aut > *smartresult = result ? new std::shared_ptr<  spot::parsed_aut >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__parsed_aut_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_aut(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "parse_aut", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_parse_aut__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_parse_aut__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_parse_aut__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'parse_aut'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::parse_aut(std::string const &,spot::bdd_dict_ptr const &,spot::environment &,spot::automaton_parser_options)\n"
    "    spot::parse_aut(std::string const &,spot::bdd_dict_ptr const &,spot::environment &)\n"
    "    spot::parse_aut(std::string const &,spot::bdd_dict_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta > tempshared1 ;
  std::shared_ptr< spot::ta > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ta" "', argument " "1"" of type '" "spot::ta *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_get_initial_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::set< spot::state const *,spot::state_ptr_less_than,std::allocator< spot::state const * > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_get_initial_states_set" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::ta const *)arg1)->get_initial_states_set();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::ta::const_states_set_t(result)), SWIGTYPE_p_std__setT_spot__state_const_p_spot__state_ptr_less_than_std__allocatorT_spot__state_const_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_get_artificial_initial_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_get_artificial_initial_state" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::state *)((spot::ta const *)arg1)->get_artificial_initial_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_succ_iter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::ta_succ_iterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_succ_iter" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_succ_iter" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (spot::ta_succ_iterator *)((spot::ta const *)arg1)->succ_iter((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__ta_succ_iterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_succ_iter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  spot::ta_succ_iterator *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_succ_iter" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_succ_iter" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ta_succ_iter" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ta_succ_iter" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (spot::ta_succ_iterator *)((spot::ta const *)arg1)->succ_iter((spot::state const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__ta_succ_iterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_succ_iter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ta_succ_iter", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_ta_succ_iter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_ta_succ_iter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ta_succ_iter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::ta::succ_iter(spot::state const *) const\n"
    "    spot::ta::succ_iter(spot::state const *,bdd) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ta_get_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::bdd_dict_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_get_dict" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::ta const *)arg1)->get_dict();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::bdd_dict > *smartresult = result ? new std::shared_ptr<  spot::bdd_dict >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_format_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::string result;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_format_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_format_state" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_format_state" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = ((spot::ta const *)arg1)->format_state((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_is_accepting_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_is_accepting_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_is_accepting_state" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_is_accepting_state" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (bool)((spot::ta const *)arg1)->is_accepting_state((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_is_livelock_accepting_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_is_livelock_accepting_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_is_livelock_accepting_state" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_is_livelock_accepting_state" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (bool)((spot::ta const *)arg1)->is_livelock_accepting_state((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_is_initial_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_is_initial_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_is_initial_state" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_is_initial_state" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (bool)((spot::ta const *)arg1)->is_initial_state((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_get_state_condition(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  bdd result;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_get_state_condition", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_get_state_condition" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_get_state_condition" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = ((spot::ta const *)arg1)->get_state_condition((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new bdd(result)), SWIGTYPE_p_bdd, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_free_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_free_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_free_state" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_free_state" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      ((spot::ta const *)arg1)->free_state((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_acc__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta const > tempshared1 ;
  std::shared_ptr< spot::ta const > *smartarg1 = 0 ;
  spot::acc_cond *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_acc" "', argument " "1"" of type '" "spot::ta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::acc_cond *) &((spot::ta const *)arg1)->acc();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_acc__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::ta *arg1 = (spot::ta *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta > tempshared1 ;
  std::shared_ptr< spot::ta > *smartarg1 = 0 ;
  spot::acc_cond *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_acc" "', argument " "1"" of type '" "spot::ta *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta > * >(argp1);
      arg1 = const_cast< spot::ta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::acc_cond *) &(arg1)->acc();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__acc_cond, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_acc(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ta_acc", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_ta_acc__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_ta_acc__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ta_acc'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::ta::acc() const\n"
    "    spot::ta::acc()\n");
  return 0;
}


SWIGINTERN PyObject *ta_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__ta_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_ta_succ_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_succ_iterator *arg1 = (spot::ta_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__ta_succ_iterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ta_succ_iterator" "', argument " "1"" of type '" "spot::ta_succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::ta_succ_iterator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ta_succ_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__ta_succ_iterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_delete_tgta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tgta *arg1 = (spot::tgta *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::tgta > tempshared1 ;
  std::shared_ptr< spot::tgta > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__tgta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_tgta" "', argument " "1"" of type '" "spot::tgta *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::tgta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::tgta > * >(argp1);
      arg1 = const_cast< spot::tgta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::tgta > * >(argp1);
      arg1 = const_cast< spot::tgta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgta_succ_iter_by_changeset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tgta *arg1 = (spot::tgta *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::tgta const > tempshared1 ;
  std::shared_ptr< spot::tgta const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::twa_succ_iterator *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "tgta_succ_iter_by_changeset", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__tgta_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgta_succ_iter_by_changeset" "', argument " "1"" of type '" "spot::tgta const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::tgta > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::tgta > * >(argp1);
      arg1 = const_cast< spot::tgta * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::tgta > * >(argp1);
      arg1 = const_cast< spot::tgta * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgta_succ_iter_by_changeset" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tgta_succ_iter_by_changeset" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgta_succ_iter_by_changeset" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (spot::twa_succ_iterator *)((spot::tgta const *)arg1)->succ_iter_by_changeset((spot::state const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__twa_succ_iterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *tgta_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__tgta_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ta_explicit__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::state_ta_explicit *arg3 = (spot::state_ta_explicit *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::ta_explicit *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ta_explicit" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ta_explicit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ta_explicit" "', argument " "3"" of type '" "spot::state_ta_explicit *""'"); 
  }
  arg3 = reinterpret_cast< spot::state_ta_explicit * >(argp3);
  {
    try {
      result = (spot::ta_explicit *)new spot::ta_explicit((spot::const_twa_ptr const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ta_explicit__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::ta_explicit *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ta_explicit" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ta_explicit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (spot::ta_explicit *)new spot::ta_explicit((spot::const_twa_ptr const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ta_explicit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ta_explicit", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_new_ta_explicit__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_new_ta_explicit__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ta_explicit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::ta_explicit::ta_explicit(spot::const_twa_ptr const &,unsigned int,spot::state_ta_explicit *)\n"
    "    spot::ta_explicit::ta_explicit(spot::const_twa_ptr const &,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ta_explicit_get_tgba(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit const > tempshared1 ;
  std::shared_ptr< spot::ta_explicit const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::const_twa_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_get_tgba" "', argument " "1"" of type '" "spot::ta_explicit const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::ta_explicit const *)arg1)->get_tgba();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr< const spot::twa > *smartresult = result ? new std::shared_ptr< const spot::twa >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_add_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  spot::state_ta_explicit *arg2 = (spot::state_ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit > tempshared1 ;
  std::shared_ptr< spot::ta_explicit > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::state_ta_explicit *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_explicit_add_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_add_state" "', argument " "1"" of type '" "spot::ta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_explicit_add_state" "', argument " "2"" of type '" "spot::state_ta_explicit *""'"); 
  }
  arg2 = reinterpret_cast< spot::state_ta_explicit * >(argp2);
  {
    try {
      result = (spot::state_ta_explicit *)(arg1)->add_state(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_add_to_initial_states_set__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit > tempshared1 ;
  std::shared_ptr< spot::ta_explicit > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_add_to_initial_states_set" "', argument " "1"" of type '" "spot::ta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_explicit_add_to_initial_states_set" "', argument " "2"" of type '" "spot::state *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ta_explicit_add_to_initial_states_set" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ta_explicit_add_to_initial_states_set" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      (arg1)->add_to_initial_states_set(arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_add_to_initial_states_set__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit > tempshared1 ;
  std::shared_ptr< spot::ta_explicit > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_add_to_initial_states_set" "', argument " "1"" of type '" "spot::ta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_explicit_add_to_initial_states_set" "', argument " "2"" of type '" "spot::state *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      (arg1)->add_to_initial_states_set(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_add_to_initial_states_set(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ta_explicit_add_to_initial_states_set", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_ta_explicit_add_to_initial_states_set__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_ta_explicit_add_to_initial_states_set__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ta_explicit_add_to_initial_states_set'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::ta_explicit::add_to_initial_states_set(spot::state *,bdd)\n"
    "    spot::ta_explicit::add_to_initial_states_set(spot::state *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ta_explicit_create_transition__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  spot::state_ta_explicit *arg2 = (spot::state_ta_explicit *) 0 ;
  bdd arg3 ;
  spot::acc_cond::mark_t arg4 ;
  spot::state_ta_explicit *arg5 = (spot::state_ta_explicit *) 0 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit > tempshared1 ;
  std::shared_ptr< spot::ta_explicit > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_create_transition" "', argument " "1"" of type '" "spot::ta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_explicit_create_transition" "', argument " "2"" of type '" "spot::state_ta_explicit *""'"); 
  }
  arg2 = reinterpret_cast< spot::state_ta_explicit * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ta_explicit_create_transition" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ta_explicit_create_transition" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ta_explicit_create_transition" "', argument " "4"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ta_explicit_create_transition" "', argument " "4"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ta_explicit_create_transition" "', argument " "5"" of type '" "spot::state_ta_explicit const *""'"); 
  }
  arg5 = reinterpret_cast< spot::state_ta_explicit * >(argp5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ta_explicit_create_transition" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      (arg1)->create_transition(arg2,arg3,arg4,(spot::state_ta_explicit const *)arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_create_transition__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  spot::state_ta_explicit *arg2 = (spot::state_ta_explicit *) 0 ;
  bdd arg3 ;
  spot::acc_cond::mark_t arg4 ;
  spot::state_ta_explicit *arg5 = (spot::state_ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit > tempshared1 ;
  std::shared_ptr< spot::ta_explicit > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_create_transition" "', argument " "1"" of type '" "spot::ta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_explicit_create_transition" "', argument " "2"" of type '" "spot::state_ta_explicit *""'"); 
  }
  arg2 = reinterpret_cast< spot::state_ta_explicit * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ta_explicit_create_transition" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ta_explicit_create_transition" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_spot__acc_cond__mark_t,  0  | SWIG_POINTER_IMPLICIT_CONV);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ta_explicit_create_transition" "', argument " "4"" of type '" "spot::acc_cond::mark_t""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ta_explicit_create_transition" "', argument " "4"" of type '" "spot::acc_cond::mark_t""'");
    } else {
      spot::acc_cond::mark_t * temp = reinterpret_cast< spot::acc_cond::mark_t * >(argp4);
      arg4 = *temp;
      if (SWIG_IsNewObj(res4)) delete temp;
    }
  }
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ta_explicit_create_transition" "', argument " "5"" of type '" "spot::state_ta_explicit const *""'"); 
  }
  arg5 = reinterpret_cast< spot::state_ta_explicit * >(argp5);
  {
    try {
      (arg1)->create_transition(arg2,arg3,arg4,(spot::state_ta_explicit const *)arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_create_transition(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ta_explicit_create_transition", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    PyObject *retobj = _wrap_ta_explicit_create_transition__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_ta_explicit_create_transition__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ta_explicit_create_transition'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::ta_explicit::create_transition(spot::state_ta_explicit *,bdd,spot::acc_cond::mark_t,spot::state_ta_explicit const *,bool)\n"
    "    spot::ta_explicit::create_transition(spot::state_ta_explicit *,bdd,spot::acc_cond::mark_t,spot::state_ta_explicit const *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ta_explicit_delete_stuttering_transitions(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit > tempshared1 ;
  std::shared_ptr< spot::ta_explicit > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_delete_stuttering_transitions" "', argument " "1"" of type '" "spot::ta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (arg1)->delete_stuttering_transitions();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ta_explicit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit > tempshared1 ;
  std::shared_ptr< spot::ta_explicit > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ta_explicit" "', argument " "1"" of type '" "spot::ta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_succ_iter__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit const > tempshared1 ;
  std::shared_ptr< spot::ta_explicit const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  spot::ta_succ_iterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_succ_iter" "', argument " "1"" of type '" "spot::ta_explicit const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_explicit_succ_iter" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      result = (spot::ta_succ_iterator *)((spot::ta_explicit const *)arg1)->succ_iter((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__ta_succ_iterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_succ_iter__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  bdd arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit const > tempshared1 ;
  std::shared_ptr< spot::ta_explicit const > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  spot::ta_succ_iterator *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_succ_iter" "', argument " "1"" of type '" "spot::ta_explicit const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_explicit_succ_iter" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ta_explicit_succ_iter" "', argument " "3"" of type '" "bdd""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ta_explicit_succ_iter" "', argument " "3"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      result = (spot::ta_succ_iterator *)((spot::ta_explicit const *)arg1)->succ_iter((spot::state const *)arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__ta_succ_iterator, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_succ_iter(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ta_explicit_succ_iter", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_ta_explicit_succ_iter__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_ta_explicit_succ_iter__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ta_explicit_succ_iter'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::ta_explicit::succ_iter(spot::state const *) const\n"
    "    spot::ta_explicit::succ_iter(spot::state const *,bdd) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ta_explicit_get_dict(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit const > tempshared1 ;
  std::shared_ptr< spot::ta_explicit const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::bdd_dict_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_get_dict" "', argument " "1"" of type '" "spot::ta_explicit const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::ta_explicit const *)arg1)->get_dict();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::bdd_dict > *smartresult = result ? new std::shared_ptr<  spot::bdd_dict >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__bdd_dict_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_get_artificial_initial_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit const > tempshared1 ;
  std::shared_ptr< spot::ta_explicit const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_get_artificial_initial_state" "', argument " "1"" of type '" "spot::ta_explicit const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::state *)((spot::ta_explicit const *)arg1)->get_artificial_initial_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_set_artificial_initial_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  spot::state_ta_explicit *arg2 = (spot::state_ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit > tempshared1 ;
  std::shared_ptr< spot::ta_explicit > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_explicit_set_artificial_initial_state", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_set_artificial_initial_state" "', argument " "1"" of type '" "spot::ta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_explicit_set_artificial_initial_state" "', argument " "2"" of type '" "spot::state_ta_explicit *""'"); 
  }
  arg2 = reinterpret_cast< spot::state_ta_explicit * >(argp2);
  {
    try {
      (arg1)->set_artificial_initial_state(arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_delete_stuttering_and_hole_successors(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  spot::state *arg2 = (spot::state *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit > tempshared1 ;
  std::shared_ptr< spot::ta_explicit > *smartarg1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_explicit_delete_stuttering_and_hole_successors", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_delete_stuttering_and_hole_successors" "', argument " "1"" of type '" "spot::ta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_spot__state, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_explicit_delete_stuttering_and_hole_successors" "', argument " "2"" of type '" "spot::state const *""'"); 
  }
  arg2 = reinterpret_cast< spot::state * >(argp2);
  {
    try {
      (arg1)->delete_stuttering_and_hole_successors((spot::state const *)arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_explicit_get_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_explicit *arg1 = (spot::ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::ta_explicit > tempshared1 ;
  std::shared_ptr< spot::ta_explicit > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::set< spot::state *,spot::state_ptr_less_than,std::allocator< spot::state * > > > result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_explicit_get_states_set" "', argument " "1"" of type '" "spot::ta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::ta_explicit > * >(argp1);
      arg1 = const_cast< spot::ta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->get_states_set();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::ta::states_set_t(result)), SWIGTYPE_p_std__setT_spot__state_p_spot__state_ptr_less_than_std__allocatorT_spot__state_p_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ta_explicit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ta_explicit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_delete_state_ta_explicit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::state_ta_explicit *arg1 = (spot::state_ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_ta_explicit, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_state_ta_explicit" "', argument " "1"" of type '" "spot::state_ta_explicit *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_ta_explicit * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *state_ta_explicit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__state_ta_explicit, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ta_explicit_succ_iterator__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::state_ta_explicit *arg1 = (spot::state_ta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  spot::ta_explicit_succ_iterator *result = 0 ;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ta_explicit_succ_iterator" "', argument " "1"" of type '" "spot::state_ta_explicit const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_ta_explicit * >(argp1);
  {
    try {
      result = (spot::ta_explicit_succ_iterator *)new spot::ta_explicit_succ_iterator((spot::state_ta_explicit const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__ta_explicit_succ_iterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ta_explicit_succ_iterator__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::state_ta_explicit *arg1 = (spot::state_ta_explicit *) 0 ;
  bdd arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::ta_explicit_succ_iterator *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ta_explicit_succ_iterator" "', argument " "1"" of type '" "spot::state_ta_explicit const *""'"); 
  }
  arg1 = reinterpret_cast< spot::state_ta_explicit * >(argp1);
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ta_explicit_succ_iterator" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ta_explicit_succ_iterator" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = (spot::ta_explicit_succ_iterator *)new spot::ta_explicit_succ_iterator((spot::state_ta_explicit const *)arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__ta_explicit_succ_iterator, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ta_explicit_succ_iterator(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ta_explicit_succ_iterator", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_new_ta_explicit_succ_iterator__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 2) {
    PyObject *retobj = _wrap_new_ta_explicit_succ_iterator__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ta_explicit_succ_iterator'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::ta_explicit_succ_iterator::ta_explicit_succ_iterator(spot::state_ta_explicit const *)\n"
    "    spot::ta_explicit_succ_iterator::ta_explicit_succ_iterator(spot::state_ta_explicit const *,bdd)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_ta_explicit_succ_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_explicit_succ_iterator *arg1 = (spot::ta_explicit_succ_iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__ta_explicit_succ_iterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ta_explicit_succ_iterator" "', argument " "1"" of type '" "spot::ta_explicit_succ_iterator *""'"); 
  }
  arg1 = reinterpret_cast< spot::ta_explicit_succ_iterator * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ta_explicit_succ_iterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__ta_explicit_succ_iterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ta_explicit_succ_iterator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_make_ta_explicit__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::state_ta_explicit *arg3 = (spot::state_ta_explicit *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::ta_explicit_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_ta_explicit" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "make_ta_explicit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "make_ta_explicit" "', argument " "3"" of type '" "spot::state_ta_explicit *""'"); 
  }
  arg3 = reinterpret_cast< spot::state_ta_explicit * >(argp3);
  {
    try {
      result = spot::make_ta_explicit((std::shared_ptr< spot::twa const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_ta_explicit__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::ta_explicit_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_ta_explicit" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "make_ta_explicit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = spot::make_ta_explicit((std::shared_ptr< spot::twa const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_ta_explicit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "make_ta_explicit", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_make_ta_explicit__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_make_ta_explicit__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'make_ta_explicit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::make_ta_explicit(spot::const_twa_ptr const &,unsigned int,spot::state_ta_explicit *)\n"
    "    spot::make_ta_explicit(spot::const_twa_ptr const &,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_tgta_explicit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::state_ta_explicit *arg3 = (spot::state_ta_explicit *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  spot::tgta_explicit *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_tgta_explicit", 3, 3, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_tgta_explicit" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_tgta_explicit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_tgta_explicit" "', argument " "3"" of type '" "spot::state_ta_explicit *""'"); 
  }
  arg3 = reinterpret_cast< spot::state_ta_explicit * >(argp3);
  {
    try {
      result = (spot::tgta_explicit *)new spot::tgta_explicit((spot::const_twa_ptr const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::tgta_explicit > *smartresult = result ? new std::shared_ptr<  spot::tgta_explicit >(result SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t, SWIG_POINTER_NEW | SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgta_explicit_get_init_state(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tgta_explicit *arg1 = (spot::tgta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::tgta_explicit const > tempshared1 ;
  std::shared_ptr< spot::tgta_explicit const > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  spot::state *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgta_explicit_get_init_state" "', argument " "1"" of type '" "spot::tgta_explicit const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::tgta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::tgta_explicit > * >(argp1);
      arg1 = const_cast< spot::tgta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::tgta_explicit > * >(argp1);
      arg1 = const_cast< spot::tgta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (spot::state *)((spot::tgta_explicit const *)arg1)->get_init_state();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__state, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgta_explicit_get_ta__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::tgta_explicit *arg1 = (spot::tgta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::tgta_explicit const > tempshared1 ;
  std::shared_ptr< spot::tgta_explicit const > *smartarg1 = 0 ;
  spot::const_ta_explicit_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgta_explicit_get_ta" "', argument " "1"" of type '" "spot::tgta_explicit const *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr< const spot::tgta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr< const spot::tgta_explicit > * >(argp1);
      arg1 = const_cast< spot::tgta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr< const spot::tgta_explicit > * >(argp1);
      arg1 = const_cast< spot::tgta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = ((spot::tgta_explicit const *)arg1)->get_ta();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr< const spot::ta_explicit > *smartresult = result ? new std::shared_ptr< const spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgta_explicit_get_ta__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::tgta_explicit *arg1 = (spot::tgta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::tgta_explicit > tempshared1 ;
  std::shared_ptr< spot::tgta_explicit > *smartarg1 = 0 ;
  spot::ta_explicit_ptr result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgta_explicit_get_ta" "', argument " "1"" of type '" "spot::tgta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::tgta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::tgta_explicit > * >(argp1);
      arg1 = const_cast< spot::tgta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::tgta_explicit > * >(argp1);
      arg1 = const_cast< spot::tgta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      result = (arg1)->get_ta();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgta_explicit_get_ta(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "tgta_explicit_get_ta", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    PyObject *retobj = _wrap_tgta_explicit_get_ta__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 1) {
    PyObject *retobj = _wrap_tgta_explicit_get_ta__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'tgta_explicit_get_ta'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::tgta_explicit::get_ta() const\n"
    "    spot::tgta_explicit::get_ta()\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_tgta_explicit(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::tgta_explicit *arg1 = (spot::tgta_explicit *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::shared_ptr< spot::tgta_explicit > tempshared1 ;
  std::shared_ptr< spot::tgta_explicit > *smartarg1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t, 0 |  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_tgta_explicit" "', argument " "1"" of type '" "spot::tgta_explicit *""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      tempshared1 = *reinterpret_cast< std::shared_ptr<  spot::tgta_explicit > * >(argp1);
      delete reinterpret_cast< std::shared_ptr<  spot::tgta_explicit > * >(argp1);
      arg1 = const_cast< spot::tgta_explicit * >(tempshared1.get());
    } else {
      smartarg1 = reinterpret_cast< std::shared_ptr<  spot::tgta_explicit > * >(argp1);
      arg1 = const_cast< spot::tgta_explicit * >((smartarg1 ? smartarg1->get() : 0));
    }
  }
  {
    try {
      (void)arg1; delete smartarg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *tgta_explicit_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *tgta_explicit_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_make_tgta_explicit__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  spot::state_ta_explicit *arg3 = (spot::state_ta_explicit *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  spot::tgta_explicit_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_tgta_explicit" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "make_tgta_explicit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_spot__state_ta_explicit, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "make_tgta_explicit" "', argument " "3"" of type '" "spot::state_ta_explicit *""'"); 
  }
  arg3 = reinterpret_cast< spot::state_ta_explicit * >(argp3);
  {
    try {
      result = spot::make_tgta_explicit((std::shared_ptr< spot::twa const > const &)*arg1,arg2,arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::tgta_explicit > *smartresult = result ? new std::shared_ptr<  spot::tgta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_tgta_explicit__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  spot::tgta_explicit_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_tgta_explicit" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "make_tgta_explicit" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = spot::make_tgta_explicit((std::shared_ptr< spot::twa const > const &)*arg1,arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::tgta_explicit > *smartresult = result ? new std::shared_ptr<  spot::tgta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_tgta_explicit(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "make_tgta_explicit", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_make_tgta_explicit__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_make_tgta_explicit__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'make_tgta_explicit'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::make_tgta_explicit(spot::const_twa_ptr const &,unsigned int,spot::state_ta_explicit *)\n"
    "    spot::make_tgta_explicit(spot::const_twa_ptr const &,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_tgba_to_ta__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  bdd arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  spot::ta_explicit_ptr result;
  
  if ((nobjs < 7) || (nobjs > 7)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_to_ta" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_to_ta" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tgba_to_ta" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "tgba_to_ta" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "tgba_to_ta" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "tgba_to_ta" "', argument " "7"" of type '" "bool""'");
  } 
  arg7 = static_cast< bool >(val7);
  {
    try {
      result = spot::tgba_to_ta((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4,arg5,arg6,arg7);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_to_ta__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  bdd arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  spot::ta_explicit_ptr result;
  
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_to_ta" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_to_ta" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tgba_to_ta" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "tgba_to_ta" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "tgba_to_ta" "', argument " "6"" of type '" "bool""'");
  } 
  arg6 = static_cast< bool >(val6);
  {
    try {
      result = spot::tgba_to_ta((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4,arg5,arg6);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_to_ta__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  bdd arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  spot::ta_explicit_ptr result;
  
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_to_ta" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_to_ta" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tgba_to_ta" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "tgba_to_ta" "', argument " "5"" of type '" "bool""'");
  } 
  arg5 = static_cast< bool >(val5);
  {
    try {
      result = spot::tgba_to_ta((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4,arg5);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_to_ta__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  bdd arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  spot::ta_explicit_ptr result;
  
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_to_ta" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_to_ta" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tgba_to_ta" "', argument " "4"" of type '" "bool""'");
  } 
  arg4 = static_cast< bool >(val4);
  {
    try {
      result = spot::tgba_to_ta((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_to_ta__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  bdd arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  spot::ta_explicit_ptr result;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_to_ta" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tgba_to_ta" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  {
    try {
      result = spot::tgba_to_ta((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2),arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_to_ta__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  bdd arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::ta_explicit_ptr result;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_to_ta" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_to_ta" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::tgba_to_ta((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tgba_to_ta(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "tgba_to_ta", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    PyObject *retobj = _wrap_tgba_to_ta__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    PyObject *retobj = _wrap_tgba_to_ta__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 4) {
    PyObject *retobj = _wrap_tgba_to_ta__SWIG_3(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 5) {
    PyObject *retobj = _wrap_tgba_to_ta__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 6) {
    PyObject *retobj = _wrap_tgba_to_ta__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 7) {
    PyObject *retobj = _wrap_tgba_to_ta__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'tgba_to_ta'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::tgba_to_ta(spot::const_twa_ptr const &,bdd,bool,bool,bool,bool,bool)\n"
    "    spot::tgba_to_ta(spot::const_twa_ptr const &,bdd,bool,bool,bool,bool)\n"
    "    spot::tgba_to_ta(spot::const_twa_ptr const &,bdd,bool,bool,bool)\n"
    "    spot::tgba_to_ta(spot::const_twa_ptr const &,bdd,bool,bool)\n"
    "    spot::tgba_to_ta(spot::const_twa_ptr const &,bdd,bool)\n"
    "    spot::tgba_to_ta(spot::const_twa_ptr const &,bdd)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_tgba_to_tgta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_twa_ptr *arg1 = 0 ;
  bdd arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_twa_ptr tempshared1 ;
  void *argp2 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  spot::tgta_explicit_ptr result;
  
  if (!SWIG_Python_UnpackTuple(args, "tgba_to_tgta", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tgba_to_tgta" "', argument " "1"" of type '" "spot::const_twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_twa_ptr * >(argp1);
      delete reinterpret_cast< spot::const_twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_bdd,  0  | 0);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tgba_to_tgta" "', argument " "2"" of type '" "bdd""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tgba_to_tgta" "', argument " "2"" of type '" "bdd""'");
    } else {
      bdd * temp = reinterpret_cast< bdd * >(argp2);
      arg2 = *temp;
      if (SWIG_IsNewObj(res2)) delete temp;
    }
  }
  {
    try {
      result = spot::tgba_to_tgta((std::shared_ptr< spot::twa const > const &)*arg1,SWIG_STD_MOVE(arg2));
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::tgta_explicit > *smartresult = result ? new std::shared_ptr<  spot::tgta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_dot__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_ta_ptr *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_ta_ptr tempshared2 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__ta_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_dot" "', argument " "2"" of type '" "spot::const_ta_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_ta_ptr * >(argp2);
      delete reinterpret_cast< spot::const_ta_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_ta_ptr * >(argp2) : &tempshared2;
    }
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "print_dot" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (std::ostream *) &spot::print_dot(*arg1,(std::shared_ptr< spot::ta const > const &)*arg2,(char const *)arg3);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_dot__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  spot::const_ta_ptr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  spot::const_ta_ptr tempshared2 ;
  std::ostream *result = 0 ;
  
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_dot" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    int newmem = 0;
    res2 = SWIG_ConvertPtrAndOwn(swig_obj[1], &argp2, SWIGTYPE_p_std__shared_ptrT_spot__ta_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "print_dot" "', argument " "2"" of type '" "spot::const_ta_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< spot::const_ta_ptr * >(argp2);
      delete reinterpret_cast< spot::const_ta_ptr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< spot::const_ta_ptr * >(argp2) : &tempshared2;
    }
  }
  {
    try {
      result = (std::ostream *) &spot::print_dot(*arg1,(std::shared_ptr< spot::ta const > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_dot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "print_dot", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_print_dot__SWIG_1(self, argc, argv);
  }
check_1:
  
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__aig_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_2;
    return _wrap_print_dot__SWIG_3(self, argc, argv);
  }
check_2:
  
  if (argc == 2) {
    PyObject *retobj = _wrap_print_dot__SWIG_5(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_4;
    PyObject *retobj = _wrap_print_dot__SWIG_0(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_4:
  
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_spot__ta_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_5;
    PyObject *retobj = _wrap_print_dot__SWIG_4(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
check_5:
  
  if (argc == 3) {
    PyObject *retobj = _wrap_print_dot__SWIG_2(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'print_dot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::print_dot(std::ostream &,spot::const_twa_ptr const &,char const *)\n"
    "    spot::print_dot(std::ostream &,spot::const_twa_ptr const &)\n"
    "    spot::print_dot(std::ostream &,spot::aig_ptr,char const *)\n"
    "    spot::print_dot(std::ostream &,spot::aig_ptr)\n"
    "    spot::print_dot(std::ostream &,spot::const_ta_ptr const &,char const *)\n"
    "    spot::print_dot(std::ostream &,spot::const_ta_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ta_statistics_edges_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_statistics *arg1 = (spot::ta_statistics *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_statistics_edges_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__ta_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_statistics_edges_set" "', argument " "1"" of type '" "spot::ta_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::ta_statistics * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ta_statistics_edges_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->edges = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_statistics_edges_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_statistics *arg1 = (spot::ta_statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__ta_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_statistics_edges_get" "', argument " "1"" of type '" "spot::ta_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::ta_statistics * >(argp1);
  result = (unsigned int) ((arg1)->edges);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_statistics_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_statistics *arg1 = (spot::ta_statistics *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_statistics_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__ta_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_statistics_states_set" "', argument " "1"" of type '" "spot::ta_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::ta_statistics * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ta_statistics_states_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_statistics_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_statistics *arg1 = (spot::ta_statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__ta_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_statistics_states_get" "', argument " "1"" of type '" "spot::ta_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::ta_statistics * >(argp1);
  result = (unsigned int) ((arg1)->states);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_statistics_acceptance_states_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_statistics *arg1 = (spot::ta_statistics *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_statistics_acceptance_states_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__ta_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_statistics_acceptance_states_set" "', argument " "1"" of type '" "spot::ta_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::ta_statistics * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ta_statistics_acceptance_states_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->acceptance_states = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_statistics_acceptance_states_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_statistics *arg1 = (spot::ta_statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__ta_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_statistics_acceptance_states_get" "', argument " "1"" of type '" "spot::ta_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::ta_statistics * >(argp1);
  result = (unsigned int) ((arg1)->acceptance_states);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ta_statistics_dump(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_statistics *arg1 = (spot::ta_statistics *) 0 ;
  std::ostream *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "ta_statistics_dump", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__ta_statistics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ta_statistics_dump" "', argument " "1"" of type '" "spot::ta_statistics const *""'"); 
  }
  arg1 = reinterpret_cast< spot::ta_statistics * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ta_statistics_dump" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ta_statistics_dump" "', argument " "2"" of type '" "std::ostream &""'"); 
  }
  arg2 = reinterpret_cast< std::ostream * >(argp2);
  {
    try {
      result = (std::ostream *) &((spot::ta_statistics const *)arg1)->dump(*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ta_statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_statistics *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ta_statistics", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (spot::ta_statistics *)new spot::ta_statistics();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_spot__ta_statistics, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ta_statistics(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::ta_statistics *arg1 = (spot::ta_statistics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_spot__ta_statistics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ta_statistics" "', argument " "1"" of type '" "spot::ta_statistics *""'"); 
  }
  arg1 = reinterpret_cast< spot::ta_statistics * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ta_statistics_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_spot__ta_statistics, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ta_statistics_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_stats_reachable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  spot::const_ta_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_ta_ptr tempshared1 ;
  spot::ta_statistics result;
  
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stats_reachable" "', argument " "1"" of type '" "spot::const_ta_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_ta_ptr * >(argp1);
      delete reinterpret_cast< spot::const_ta_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_ta_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::stats_reachable((std::shared_ptr< spot::ta const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj((new spot::ta_statistics(result)), SWIGTYPE_p_spot__ta_statistics, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stats_reachable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "stats_reachable", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_spot__twa_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (!_v) goto check_1;
    return _wrap_stats_reachable__SWIG_0(self, argc, argv);
  }
check_1:
  
  if (argc == 1) {
    PyObject *retobj = _wrap_stats_reachable__SWIG_1(self, argc, argv);
    if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj;
    SWIG_fail;
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'stats_reachable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    spot::stats_reachable(spot::const_twa_ptr const &)\n"
    "    spot::stats_reachable(spot::const_ta_ptr const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_minimize_ta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_ta_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_ta_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::ta_explicit_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__ta_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_ta" "', argument " "1"" of type '" "spot::const_ta_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_ta_ptr * >(argp1);
      delete reinterpret_cast< spot::const_ta_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_ta_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::minimize_ta((std::shared_ptr< spot::ta const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::ta_explicit > *smartresult = result ? new std::shared_ptr<  spot::ta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__ta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_minimize_tgta(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::const_tgta_explicit_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::const_tgta_explicit_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::tgta_explicit_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "minimize_tgta" "', argument " "1"" of type '" "spot::const_tgta_explicit_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::const_tgta_explicit_ptr * >(argp1);
      delete reinterpret_cast< spot::const_tgta_explicit_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::const_tgta_explicit_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = spot::minimize_tgta((std::shared_ptr< spot::tgta_explicit const > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::tgta_explicit > *smartresult = result ? new std::shared_ptr<  spot::tgta_explicit >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__tgta_explicit_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ostream(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = (std::ostream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__ostream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ostream" "', argument " "1"" of type '" "std::ostream *""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ostream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__ostream, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_ofstream(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  std::ofstream *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ofstream" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (std::ofstream *)new std::ofstream((char const *)arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ofstream, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ofstream(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ofstream *arg1 = (std::ofstream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__ofstream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ofstream" "', argument " "1"" of type '" "std::ofstream *""'"); 
  }
  arg1 = reinterpret_cast< std::ofstream * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ofstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__ofstream, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ofstream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ostringstream(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostringstream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "new_ostringstream", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (std::ostringstream *)new std::ostringstream();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostringstream, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ostringstream_str(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostringstream *arg1 = (std::ostringstream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__ostringstream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ostringstream_str" "', argument " "1"" of type '" "std::ostringstream const *""'"); 
  }
  arg1 = reinterpret_cast< std::ostringstream * >(argp1);
  {
    try {
      result = ((std::ostringstream const *)arg1)->str();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ostringstream(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostringstream *arg1 = (std::ostringstream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__ostringstream, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ostringstream" "', argument " "1"" of type '" "std::ostringstream *""'"); 
  }
  arg1 = reinterpret_cast< std::ostringstream * >(argp1);
  {
    try {
      delete arg1;
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ostringstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__ostringstream, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ostringstream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_fnode_instances_check(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  bool result;
  
  if (!SWIG_Python_UnpackTuple(args, "fnode_instances_check", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (bool)fnode_instances_check();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ensure_digraph(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_ptr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_ptr tempshared1 ;
  PyObject *swig_obj[1] ;
  spot::twa_graph_ptr result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ensure_digraph" "', argument " "1"" of type '" "spot::twa_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    try {
      result = ensure_digraph((std::shared_ptr< spot::twa > const &)*arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  {
    std::shared_ptr<  spot::twa_graph > *smartresult = result ? new std::shared_ptr<  spot::twa_graph >(result) : 0;
    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t, SWIG_POINTER_OWN);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_cout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "get_cout", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (std::ostream *) &get_cout();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nl_cout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "nl_cout", 0, 0, 0)) SWIG_fail;
  {
    try {
      nl_cout();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_cerr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *result = 0 ;
  
  if (!SWIG_Python_UnpackTuple(args, "get_cerr", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (std::ostream *) &get_cerr();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nl_cerr(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "nl_cerr", 0, 0, 0)) SWIG_fail;
  {
    try {
      nl_cerr();
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_on(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::ostream *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "print_on", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_on" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_on" "', argument " "1"" of type '" "std::ostream &""'"); 
  }
  arg1 = reinterpret_cast< std::ostream * >(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 '" "print_on" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "print_on" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      print_on(*arg1,(std::string const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_unblock_signal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "unblock_signal" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (int)unblock_signal(arg1);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_states_and(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  spot::twa_graph_ptr *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  spot::twa_graph_ptr tempshared1 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  unsigned int result;
  
  if (!SWIG_Python_UnpackTuple(args, "states_and", 2, 2, swig_obj)) SWIG_fail;
  {
    int newmem = 0;
    res1 = SWIG_ConvertPtrAndOwn(swig_obj[0], &argp1, SWIGTYPE_p_std__shared_ptrT_spot__twa_graph_t,  0 , &newmem);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "states_and" "', argument " "1"" of type '" "spot::twa_graph_ptr const &""'");
    }
    if (newmem & SWIG_CAST_NEW_MEMORY) {
      if (argp1) tempshared1 = *reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      delete reinterpret_cast< spot::twa_graph_ptr * >(argp1);
      arg1 = &tempshared1;
    } else {
      arg1 = (argp1) ? reinterpret_cast< spot::twa_graph_ptr * >(argp1) : &tempshared1;
    }
  }
  {
    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 '" "states_and" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "states_and" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (unsigned int)states_and((std::shared_ptr< spot::twa_graph > const &)*arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
    }
    catch (...) {
      handle_any_exception();
      SWIG_fail;
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


static PyMethodDef SwigMethods[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, 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", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "new_parse_error", _wrap_new_parse_error, METH_O, NULL},
	 { "delete_parse_error", _wrap_delete_parse_error, METH_O, NULL},
	 { "parse_error_swigregister", parse_error_swigregister, METH_O, NULL},
	 { "parse_error_swiginit", parse_error_swiginit, METH_VARARGS, NULL},
	 { "new_parallel_policy", _wrap_new_parallel_policy, METH_VARARGS, NULL},
	 { "parallel_policy_nthreads", _wrap_parallel_policy_nthreads, METH_O, NULL},
	 { "delete_parallel_policy", _wrap_delete_parallel_policy, METH_O, NULL},
	 { "parallel_policy_swigregister", parallel_policy_swigregister, METH_O, NULL},
	 { "parallel_policy_swiginit", parallel_policy_swiginit, METH_VARARGS, NULL},
	 { "version", _wrap_version, METH_NOARGS, NULL},
	 { "new_minato_isop", _wrap_new_minato_isop, METH_VARARGS, NULL},
	 { "minato_isop_next", _wrap_minato_isop_next, METH_O, NULL},
	 { "delete_minato_isop", _wrap_delete_minato_isop, METH_O, NULL},
	 { "minato_isop_swigregister", minato_isop_swigregister, METH_O, NULL},
	 { "minato_isop_swiginit", minato_isop_swiginit, METH_VARARGS, NULL},
	 { "option_map_parse_options", _wrap_option_map_parse_options, METH_VARARGS, NULL},
	 { "option_map_get", _wrap_option_map_get, METH_VARARGS, NULL},
	 { "option_map_get_str", _wrap_option_map_get_str, METH_VARARGS, NULL},
	 { "option_map_set_if_unset", _wrap_option_map_set_if_unset, METH_VARARGS, NULL},
	 { "option_map_set_str", _wrap_option_map_set_str, METH_VARARGS, NULL},
	 { "option_map_report_unused_options", _wrap_option_map_report_unused_options, METH_O, NULL},
	 { "option_map_set", _wrap_option_map_set, METH_VARARGS, NULL},
	 { "new_option_map", _wrap_new_option_map, METH_NOARGS, NULL},
	 { "delete_option_map", _wrap_delete_option_map, METH_O, NULL},
	 { "option_map_swigregister", option_map_swigregister, METH_O, NULL},
	 { "option_map_swiginit", option_map_swiginit, METH_VARARGS, NULL},
	 { "srand", _wrap_srand, METH_O, NULL},
	 { "rrand", _wrap_rrand, METH_VARARGS, NULL},
	 { "mrand", _wrap_mrand, METH_O, NULL},
	 { "drand", _wrap_drand, METH_NOARGS, NULL},
	 { "nrand", _wrap_nrand, METH_NOARGS, NULL},
	 { "escape_rfc4180", _wrap_escape_rfc4180, METH_VARARGS, NULL},
	 { "escape_latex", _wrap_escape_latex, METH_VARARGS, NULL},
	 { "escape_html", _wrap_escape_html, METH_VARARGS, NULL},
	 { "escape_str", _wrap_escape_str, METH_VARARGS, NULL},
	 { "quote_shell_string", _wrap_quote_shell_string, METH_VARARGS, NULL},
	 { "new_trival", _wrap_new_trival, METH_VARARGS, NULL},
	 { "trival_maybe", _wrap_trival_maybe, METH_NOARGS, NULL},
	 { "trival_is_known", _wrap_trival_is_known, METH_O, NULL},
	 { "trival_is_maybe", _wrap_trival_is_maybe, METH_O, NULL},
	 { "trival_is_true", _wrap_trival_is_true, METH_O, NULL},
	 { "trival_is_false", _wrap_trival_is_false, METH_O, NULL},
	 { "trival_val", _wrap_trival_val, METH_O, NULL},
	 { "trival___nonzero__", _wrap_trival___nonzero__, METH_O, NULL},
	 { "trival___repr__", _wrap_trival___repr__, METH_O, NULL},
	 { "trival___str__", _wrap_trival___str__, METH_O, NULL},
	 { "trival___neg__", _wrap_trival___neg__, METH_O, NULL},
	 { "trival___and__", _wrap_trival___and__, METH_VARARGS, NULL},
	 { "trival___or__", _wrap_trival___or__, METH_VARARGS, NULL},
	 { "trival___eq__", _wrap_trival___eq__, METH_VARARGS, NULL},
	 { "trival___ne__", _wrap_trival___ne__, METH_VARARGS, NULL},
	 { "delete_trival", _wrap_delete_trival, METH_O, NULL},
	 { "trival_swigregister", trival_swigregister, METH_O, NULL},
	 { "trival_swiginit", trival_swiginit, METH_VARARGS, NULL},
	 { "new_formula", _wrap_new_formula, METH_VARARGS, NULL},
	 { "delete_formula", _wrap_delete_formula, METH_O, NULL},
	 { "formula___lt__", _wrap_formula___lt__, METH_VARARGS, NULL},
	 { "formula___le__", _wrap_formula___le__, METH_VARARGS, NULL},
	 { "formula___gt__", _wrap_formula___gt__, METH_VARARGS, NULL},
	 { "formula___ge__", _wrap_formula___ge__, METH_VARARGS, NULL},
	 { "formula___eq__", _wrap_formula___eq__, METH_VARARGS, NULL},
	 { "formula___ne__", _wrap_formula___ne__, METH_VARARGS, NULL},
	 { "formula___nonzero__", _wrap_formula___nonzero__, METH_O, NULL},
	 { "formula_unbounded", _wrap_formula_unbounded, METH_NOARGS, NULL},
	 { "formula_ap", _wrap_formula_ap, METH_VARARGS, NULL},
	 { "formula_unop", _wrap_formula_unop, METH_VARARGS, NULL},
	 { "formula_Not", _wrap_formula_Not, METH_O, NULL},
	 { "formula_X", _wrap_formula_X, METH_VARARGS, NULL},
	 { "formula_F", _wrap_formula_F, METH_VARARGS, NULL},
	 { "formula_G", _wrap_formula_G, METH_VARARGS, NULL},
	 { "formula_Closure", _wrap_formula_Closure, METH_O, NULL},
	 { "formula_NegClosure", _wrap_formula_NegClosure, METH_O, NULL},
	 { "formula_NegClosureMarked", _wrap_formula_NegClosureMarked, METH_O, NULL},
	 { "formula_first_match", _wrap_formula_first_match, METH_O, NULL},
	 { "formula_binop", _wrap_formula_binop, METH_VARARGS, NULL},
	 { "formula_Xor", _wrap_formula_Xor, METH_VARARGS, NULL},
	 { "formula_Implies", _wrap_formula_Implies, METH_VARARGS, NULL},
	 { "formula_Equiv", _wrap_formula_Equiv, METH_VARARGS, NULL},
	 { "formula_U", _wrap_formula_U, METH_VARARGS, NULL},
	 { "formula_R", _wrap_formula_R, METH_VARARGS, NULL},
	 { "formula_W", _wrap_formula_W, METH_VARARGS, NULL},
	 { "formula_M", _wrap_formula_M, METH_VARARGS, NULL},
	 { "formula_EConcat", _wrap_formula_EConcat, METH_VARARGS, NULL},
	 { "formula_EConcatMarked", _wrap_formula_EConcatMarked, METH_VARARGS, NULL},
	 { "formula_UConcat", _wrap_formula_UConcat, METH_VARARGS, NULL},
	 { "formula_multop", _wrap_formula_multop, METH_VARARGS, NULL},
	 { "formula_Or", _wrap_formula_Or, METH_O, NULL},
	 { "formula_OrRat", _wrap_formula_OrRat, METH_O, NULL},
	 { "formula_And", _wrap_formula_And, METH_O, NULL},
	 { "formula_AndRat", _wrap_formula_AndRat, METH_O, NULL},
	 { "formula_AndNLM", _wrap_formula_AndNLM, METH_O, NULL},
	 { "formula_Concat", _wrap_formula_Concat, METH_O, NULL},
	 { "formula_Fusion", _wrap_formula_Fusion, METH_O, NULL},
	 { "formula_bunop", _wrap_formula_bunop, METH_VARARGS, NULL},
	 { "formula_Star", _wrap_formula_Star, METH_VARARGS, NULL},
	 { "formula_FStar", _wrap_formula_FStar, METH_VARARGS, NULL},
	 { "formula_nested_unop_range", _wrap_formula_nested_unop_range, METH_VARARGS, NULL},
	 { "formula_sugar_goto", _wrap_formula_sugar_goto, METH_VARARGS, NULL},
	 { "formula_sugar_equal", _wrap_formula_sugar_equal, METH_VARARGS, NULL},
	 { "formula_sugar_delay", _wrap_formula_sugar_delay, METH_VARARGS, NULL},
	 { "formula_kind", _wrap_formula_kind, METH_O, NULL},
	 { "formula_kindstr", _wrap_formula_kindstr, METH_O, NULL},
	 { "formula__is", _wrap_formula__is, METH_VARARGS, NULL},
	 { "formula_get_child_of", _wrap_formula_get_child_of, METH_VARARGS, NULL},
	 { "formula_min", _wrap_formula_min, METH_O, NULL},
	 { "formula_max", _wrap_formula_max, METH_O, NULL},
	 { "formula_size", _wrap_formula_size, METH_O, NULL},
	 { "formula_is_leaf", _wrap_formula_is_leaf, METH_O, NULL},
	 { "formula_id", _wrap_formula_id, METH_O, NULL},
	 { "formula_ff", _wrap_formula_ff, METH_NOARGS, NULL},
	 { "formula_is_ff", _wrap_formula_is_ff, METH_O, NULL},
	 { "formula_tt", _wrap_formula_tt, METH_NOARGS, NULL},
	 { "formula_is_tt", _wrap_formula_is_tt, METH_O, NULL},
	 { "formula_eword", _wrap_formula_eword, METH_NOARGS, NULL},
	 { "formula_is_eword", _wrap_formula_is_eword, METH_O, NULL},
	 { "formula_is_constant", _wrap_formula_is_constant, METH_O, NULL},
	 { "formula_is_Kleene_star", _wrap_formula_is_Kleene_star, METH_O, NULL},
	 { "formula_one_star", _wrap_formula_one_star, METH_NOARGS, NULL},
	 { "formula_one_plus", _wrap_formula_one_plus, METH_NOARGS, NULL},
	 { "formula_is_literal", _wrap_formula_is_literal, METH_O, NULL},
	 { "formula_ap_name", _wrap_formula_ap_name, METH_O, NULL},
	 { "formula_dump", _wrap_formula_dump, METH_VARARGS, NULL},
	 { "formula_all_but", _wrap_formula_all_but, METH_VARARGS, NULL},
	 { "formula_boolean_count", _wrap_formula_boolean_count, METH_O, NULL},
	 { "formula_boolean_operands", _wrap_formula_boolean_operands, METH_VARARGS, NULL},
	 { "formula_is_boolean", _wrap_formula_is_boolean, METH_O, NULL},
	 { "formula_is_sugar_free_boolean", _wrap_formula_is_sugar_free_boolean, METH_O, NULL},
	 { "formula_is_in_nenoform", _wrap_formula_is_in_nenoform, METH_O, NULL},
	 { "formula_is_syntactic_stutter_invariant", _wrap_formula_is_syntactic_stutter_invariant, METH_O, NULL},
	 { "formula_is_sugar_free_ltl", _wrap_formula_is_sugar_free_ltl, METH_O, NULL},
	 { "formula_is_ltl_formula", _wrap_formula_is_ltl_formula, METH_O, NULL},
	 { "formula_is_psl_formula", _wrap_formula_is_psl_formula, METH_O, NULL},
	 { "formula_is_sere_formula", _wrap_formula_is_sere_formula, METH_O, NULL},
	 { "formula_is_finite", _wrap_formula_is_finite, METH_O, NULL},
	 { "formula_is_eventual", _wrap_formula_is_eventual, METH_O, NULL},
	 { "formula_is_universal", _wrap_formula_is_universal, METH_O, NULL},
	 { "formula_is_syntactic_safety", _wrap_formula_is_syntactic_safety, METH_O, NULL},
	 { "formula_is_syntactic_guarantee", _wrap_formula_is_syntactic_guarantee, METH_O, NULL},
	 { "formula_is_syntactic_obligation", _wrap_formula_is_syntactic_obligation, METH_O, NULL},
	 { "formula_is_syntactic_recurrence", _wrap_formula_is_syntactic_recurrence, METH_O, NULL},
	 { "formula_is_syntactic_persistence", _wrap_formula_is_syntactic_persistence, METH_O, NULL},
	 { "formula_is_marked", _wrap_formula_is_marked, METH_O, NULL},
	 { "formula_accepts_eword", _wrap_formula_accepts_eword, METH_O, NULL},
	 { "formula_has_lbt_atomic_props", _wrap_formula_has_lbt_atomic_props, METH_O, NULL},
	 { "formula_has_spin_atomic_props", _wrap_formula_has_spin_atomic_props, METH_O, NULL},
	 { "formula___cmp__", _wrap_formula___cmp__, METH_VARARGS, NULL},
	 { "formula___hash__", _wrap_formula___hash__, METH_O, NULL},
	 { "formula___len__", _wrap_formula___len__, METH_O, NULL},
	 { "formula___getitem__", _wrap_formula___getitem__, METH_VARARGS, NULL},
	 { "formula___repr__", _wrap_formula___repr__, METH_O, NULL},
	 { "formula___str__", _wrap_formula___str__, METH_O, NULL},
	 { "formula_swigregister", formula_swigregister, METH_O, NULL},
	 { "formula_swiginit", formula_swiginit, METH_VARARGS, NULL},
	 { "print_formula_props", _wrap_print_formula_props, METH_VARARGS, NULL},
	 { "list_formula_props", _wrap_list_formula_props, METH_O, NULL},
	 { "liststr_iterator", _wrap_liststr_iterator, METH_O, NULL},
	 { "liststr___nonzero__", _wrap_liststr___nonzero__, METH_O, NULL},
	 { "liststr___bool__", _wrap_liststr___bool__, METH_O, NULL},
	 { "liststr___len__", _wrap_liststr___len__, METH_O, NULL},
	 { "liststr___getslice__", _wrap_liststr___getslice__, METH_VARARGS, NULL},
	 { "liststr___setslice__", _wrap_liststr___setslice__, METH_VARARGS, NULL},
	 { "liststr___delslice__", _wrap_liststr___delslice__, METH_VARARGS, NULL},
	 { "liststr___delitem__", _wrap_liststr___delitem__, METH_VARARGS, NULL},
	 { "liststr___getitem__", _wrap_liststr___getitem__, METH_VARARGS, NULL},
	 { "liststr___setitem__", _wrap_liststr___setitem__, METH_VARARGS, NULL},
	 { "liststr_pop", _wrap_liststr_pop, METH_O, NULL},
	 { "liststr_append", _wrap_liststr_append, METH_VARARGS, NULL},
	 { "liststr_empty", _wrap_liststr_empty, METH_O, NULL},
	 { "liststr_size", _wrap_liststr_size, METH_O, NULL},
	 { "liststr_swap", _wrap_liststr_swap, METH_VARARGS, NULL},
	 { "liststr_begin", _wrap_liststr_begin, METH_O, NULL},
	 { "liststr_end", _wrap_liststr_end, METH_O, NULL},
	 { "liststr_rbegin", _wrap_liststr_rbegin, METH_O, NULL},
	 { "liststr_rend", _wrap_liststr_rend, METH_O, NULL},
	 { "liststr_clear", _wrap_liststr_clear, METH_O, NULL},
	 { "liststr_get_allocator", _wrap_liststr_get_allocator, METH_O, NULL},
	 { "liststr_pop_back", _wrap_liststr_pop_back, METH_O, NULL},
	 { "liststr_erase", _wrap_liststr_erase, METH_VARARGS, NULL},
	 { "new_liststr", _wrap_new_liststr, METH_VARARGS, NULL},
	 { "liststr_push_back", _wrap_liststr_push_back, METH_VARARGS, NULL},
	 { "liststr_front", _wrap_liststr_front, METH_O, NULL},
	 { "liststr_back", _wrap_liststr_back, METH_O, NULL},
	 { "liststr_assign", _wrap_liststr_assign, METH_VARARGS, NULL},
	 { "liststr_resize", _wrap_liststr_resize, METH_VARARGS, NULL},
	 { "liststr_insert", _wrap_liststr_insert, METH_VARARGS, NULL},
	 { "liststr_pop_front", _wrap_liststr_pop_front, METH_O, NULL},
	 { "liststr_push_front", _wrap_liststr_push_front, METH_VARARGS, NULL},
	 { "liststr_reverse", _wrap_liststr_reverse, METH_O, NULL},
	 { "delete_liststr", _wrap_delete_liststr, METH_O, NULL},
	 { "liststr_swigregister", liststr_swigregister, METH_O, NULL},
	 { "liststr_swiginit", liststr_swiginit, METH_VARARGS, NULL},
	 { "new_pairunsigned", _wrap_new_pairunsigned, METH_VARARGS, NULL},
	 { "pairunsigned_first_set", _wrap_pairunsigned_first_set, METH_VARARGS, NULL},
	 { "pairunsigned_first_get", _wrap_pairunsigned_first_get, METH_O, NULL},
	 { "pairunsigned_second_set", _wrap_pairunsigned_second_set, METH_VARARGS, NULL},
	 { "pairunsigned_second_get", _wrap_pairunsigned_second_get, METH_O, NULL},
	 { "delete_pairunsigned", _wrap_delete_pairunsigned, METH_O, NULL},
	 { "pairunsigned_swigregister", pairunsigned_swigregister, METH_O, NULL},
	 { "pairunsigned_swiginit", pairunsigned_swiginit, METH_VARARGS, NULL},
	 { "new_pairmark_t", _wrap_new_pairmark_t, METH_VARARGS, NULL},
	 { "pairmark_t_first_set", _wrap_pairmark_t_first_set, METH_VARARGS, NULL},
	 { "pairmark_t_first_get", _wrap_pairmark_t_first_get, METH_O, NULL},
	 { "pairmark_t_second_set", _wrap_pairmark_t_second_set, METH_VARARGS, NULL},
	 { "pairmark_t_second_get", _wrap_pairmark_t_second_get, METH_O, NULL},
	 { "delete_pairmark_t", _wrap_delete_pairmark_t, METH_O, NULL},
	 { "pairmark_t_swigregister", pairmark_t_swigregister, METH_O, NULL},
	 { "pairmark_t_swiginit", pairmark_t_swiginit, METH_VARARGS, NULL},
	 { "new_pairintacccode", _wrap_new_pairintacccode, METH_VARARGS, NULL},
	 { "pairintacccode_first_set", _wrap_pairintacccode_first_set, METH_VARARGS, NULL},
	 { "pairintacccode_first_get", _wrap_pairintacccode_first_get, METH_O, NULL},
	 { "pairintacccode_second_set", _wrap_pairintacccode_second_set, METH_VARARGS, NULL},
	 { "pairintacccode_second_get", _wrap_pairintacccode_second_get, METH_O, NULL},
	 { "delete_pairintacccode", _wrap_delete_pairintacccode, METH_O, NULL},
	 { "pairintacccode_swigregister", pairintacccode_swigregister, METH_O, NULL},
	 { "pairintacccode_swiginit", pairintacccode_swiginit, METH_VARARGS, NULL},
	 { "new_pairintacccond", _wrap_new_pairintacccond, METH_VARARGS, NULL},
	 { "pairintacccond_first_set", _wrap_pairintacccond_first_set, METH_VARARGS, NULL},
	 { "pairintacccond_first_get", _wrap_pairintacccond_first_get, METH_O, NULL},
	 { "pairintacccond_second_set", _wrap_pairintacccond_second_set, METH_VARARGS, NULL},
	 { "pairintacccond_second_get", _wrap_pairintacccond_second_get, METH_O, NULL},
	 { "delete_pairintacccond", _wrap_delete_pairintacccond, METH_O, NULL},
	 { "pairintacccond_swigregister", pairintacccond_swigregister, METH_O, NULL},
	 { "pairintacccond_swiginit", pairintacccond_swiginit, METH_VARARGS, NULL},
	 { "vectorformula_iterator", _wrap_vectorformula_iterator, METH_O, NULL},
	 { "vectorformula___nonzero__", _wrap_vectorformula___nonzero__, METH_O, NULL},
	 { "vectorformula___bool__", _wrap_vectorformula___bool__, METH_O, NULL},
	 { "vectorformula___len__", _wrap_vectorformula___len__, METH_O, NULL},
	 { "vectorformula___getslice__", _wrap_vectorformula___getslice__, METH_VARARGS, NULL},
	 { "vectorformula___setslice__", _wrap_vectorformula___setslice__, METH_VARARGS, NULL},
	 { "vectorformula___delslice__", _wrap_vectorformula___delslice__, METH_VARARGS, NULL},
	 { "vectorformula___delitem__", _wrap_vectorformula___delitem__, METH_VARARGS, NULL},
	 { "vectorformula___getitem__", _wrap_vectorformula___getitem__, METH_VARARGS, NULL},
	 { "vectorformula___setitem__", _wrap_vectorformula___setitem__, METH_VARARGS, NULL},
	 { "vectorformula_pop", _wrap_vectorformula_pop, METH_O, NULL},
	 { "vectorformula_append", _wrap_vectorformula_append, METH_VARARGS, NULL},
	 { "vectorformula_empty", _wrap_vectorformula_empty, METH_O, NULL},
	 { "vectorformula_size", _wrap_vectorformula_size, METH_O, NULL},
	 { "vectorformula_swap", _wrap_vectorformula_swap, METH_VARARGS, NULL},
	 { "vectorformula_begin", _wrap_vectorformula_begin, METH_O, NULL},
	 { "vectorformula_end", _wrap_vectorformula_end, METH_O, NULL},
	 { "vectorformula_rbegin", _wrap_vectorformula_rbegin, METH_O, NULL},
	 { "vectorformula_rend", _wrap_vectorformula_rend, METH_O, NULL},
	 { "vectorformula_clear", _wrap_vectorformula_clear, METH_O, NULL},
	 { "vectorformula_get_allocator", _wrap_vectorformula_get_allocator, METH_O, NULL},
	 { "vectorformula_pop_back", _wrap_vectorformula_pop_back, METH_O, NULL},
	 { "vectorformula_erase", _wrap_vectorformula_erase, METH_VARARGS, NULL},
	 { "new_vectorformula", _wrap_new_vectorformula, METH_VARARGS, NULL},
	 { "vectorformula_push_back", _wrap_vectorformula_push_back, METH_VARARGS, NULL},
	 { "vectorformula_front", _wrap_vectorformula_front, METH_O, NULL},
	 { "vectorformula_back", _wrap_vectorformula_back, METH_O, NULL},
	 { "vectorformula_assign", _wrap_vectorformula_assign, METH_VARARGS, NULL},
	 { "vectorformula_resize", _wrap_vectorformula_resize, METH_VARARGS, NULL},
	 { "vectorformula_insert", _wrap_vectorformula_insert, METH_VARARGS, NULL},
	 { "vectorformula_reserve", _wrap_vectorformula_reserve, METH_VARARGS, NULL},
	 { "vectorformula_capacity", _wrap_vectorformula_capacity, METH_O, NULL},
	 { "delete_vectorformula", _wrap_delete_vectorformula, METH_O, NULL},
	 { "vectorformula_swigregister", vectorformula_swigregister, METH_O, NULL},
	 { "vectorformula_swiginit", vectorformula_swiginit, METH_VARARGS, NULL},
	 { "vectorunsigned_iterator", _wrap_vectorunsigned_iterator, METH_O, NULL},
	 { "vectorunsigned___nonzero__", _wrap_vectorunsigned___nonzero__, METH_O, NULL},
	 { "vectorunsigned___bool__", _wrap_vectorunsigned___bool__, METH_O, NULL},
	 { "vectorunsigned___len__", _wrap_vectorunsigned___len__, METH_O, NULL},
	 { "vectorunsigned___getslice__", _wrap_vectorunsigned___getslice__, METH_VARARGS, NULL},
	 { "vectorunsigned___setslice__", _wrap_vectorunsigned___setslice__, METH_VARARGS, NULL},
	 { "vectorunsigned___delslice__", _wrap_vectorunsigned___delslice__, METH_VARARGS, NULL},
	 { "vectorunsigned___delitem__", _wrap_vectorunsigned___delitem__, METH_VARARGS, NULL},
	 { "vectorunsigned___getitem__", _wrap_vectorunsigned___getitem__, METH_VARARGS, NULL},
	 { "vectorunsigned___setitem__", _wrap_vectorunsigned___setitem__, METH_VARARGS, NULL},
	 { "vectorunsigned_pop", _wrap_vectorunsigned_pop, METH_O, NULL},
	 { "vectorunsigned_append", _wrap_vectorunsigned_append, METH_VARARGS, NULL},
	 { "vectorunsigned_empty", _wrap_vectorunsigned_empty, METH_O, NULL},
	 { "vectorunsigned_size", _wrap_vectorunsigned_size, METH_O, NULL},
	 { "vectorunsigned_swap", _wrap_vectorunsigned_swap, METH_VARARGS, NULL},
	 { "vectorunsigned_begin", _wrap_vectorunsigned_begin, METH_O, NULL},
	 { "vectorunsigned_end", _wrap_vectorunsigned_end, METH_O, NULL},
	 { "vectorunsigned_rbegin", _wrap_vectorunsigned_rbegin, METH_O, NULL},
	 { "vectorunsigned_rend", _wrap_vectorunsigned_rend, METH_O, NULL},
	 { "vectorunsigned_clear", _wrap_vectorunsigned_clear, METH_O, NULL},
	 { "vectorunsigned_get_allocator", _wrap_vectorunsigned_get_allocator, METH_O, NULL},
	 { "vectorunsigned_pop_back", _wrap_vectorunsigned_pop_back, METH_O, NULL},
	 { "vectorunsigned_erase", _wrap_vectorunsigned_erase, METH_VARARGS, NULL},
	 { "new_vectorunsigned", _wrap_new_vectorunsigned, METH_VARARGS, NULL},
	 { "vectorunsigned_push_back", _wrap_vectorunsigned_push_back, METH_VARARGS, NULL},
	 { "vectorunsigned_front", _wrap_vectorunsigned_front, METH_O, NULL},
	 { "vectorunsigned_back", _wrap_vectorunsigned_back, METH_O, NULL},
	 { "vectorunsigned_assign", _wrap_vectorunsigned_assign, METH_VARARGS, NULL},
	 { "vectorunsigned_resize", _wrap_vectorunsigned_resize, METH_VARARGS, NULL},
	 { "vectorunsigned_insert", _wrap_vectorunsigned_insert, METH_VARARGS, NULL},
	 { "vectorunsigned_reserve", _wrap_vectorunsigned_reserve, METH_VARARGS, NULL},
	 { "vectorunsigned_capacity", _wrap_vectorunsigned_capacity, METH_O, NULL},
	 { "delete_vectorunsigned", _wrap_delete_vectorunsigned, METH_O, NULL},
	 { "vectorunsigned_swigregister", vectorunsigned_swigregister, METH_O, NULL},
	 { "vectorunsigned_swiginit", vectorunsigned_swiginit, METH_VARARGS, NULL},
	 { "vectorpairunsigned_iterator", _wrap_vectorpairunsigned_iterator, METH_O, NULL},
	 { "vectorpairunsigned___nonzero__", _wrap_vectorpairunsigned___nonzero__, METH_O, NULL},
	 { "vectorpairunsigned___bool__", _wrap_vectorpairunsigned___bool__, METH_O, NULL},
	 { "vectorpairunsigned___len__", _wrap_vectorpairunsigned___len__, METH_O, NULL},
	 { "vectorpairunsigned___getslice__", _wrap_vectorpairunsigned___getslice__, METH_VARARGS, NULL},
	 { "vectorpairunsigned___setslice__", _wrap_vectorpairunsigned___setslice__, METH_VARARGS, NULL},
	 { "vectorpairunsigned___delslice__", _wrap_vectorpairunsigned___delslice__, METH_VARARGS, NULL},
	 { "vectorpairunsigned___delitem__", _wrap_vectorpairunsigned___delitem__, METH_VARARGS, NULL},
	 { "vectorpairunsigned___getitem__", _wrap_vectorpairunsigned___getitem__, METH_VARARGS, NULL},
	 { "vectorpairunsigned___setitem__", _wrap_vectorpairunsigned___setitem__, METH_VARARGS, NULL},
	 { "vectorpairunsigned_pop", _wrap_vectorpairunsigned_pop, METH_O, NULL},
	 { "vectorpairunsigned_append", _wrap_vectorpairunsigned_append, METH_VARARGS, NULL},
	 { "vectorpairunsigned_empty", _wrap_vectorpairunsigned_empty, METH_O, NULL},
	 { "vectorpairunsigned_size", _wrap_vectorpairunsigned_size, METH_O, NULL},
	 { "vectorpairunsigned_swap", _wrap_vectorpairunsigned_swap, METH_VARARGS, NULL},
	 { "vectorpairunsigned_begin", _wrap_vectorpairunsigned_begin, METH_O, NULL},
	 { "vectorpairunsigned_end", _wrap_vectorpairunsigned_end, METH_O, NULL},
	 { "vectorpairunsigned_rbegin", _wrap_vectorpairunsigned_rbegin, METH_O, NULL},
	 { "vectorpairunsigned_rend", _wrap_vectorpairunsigned_rend, METH_O, NULL},
	 { "vectorpairunsigned_clear", _wrap_vectorpairunsigned_clear, METH_O, NULL},
	 { "vectorpairunsigned_get_allocator", _wrap_vectorpairunsigned_get_allocator, METH_O, NULL},
	 { "vectorpairunsigned_pop_back", _wrap_vectorpairunsigned_pop_back, METH_O, NULL},
	 { "vectorpairunsigned_erase", _wrap_vectorpairunsigned_erase, METH_VARARGS, NULL},
	 { "new_vectorpairunsigned", _wrap_new_vectorpairunsigned, METH_VARARGS, NULL},
	 { "vectorpairunsigned_push_back", _wrap_vectorpairunsigned_push_back, METH_VARARGS, NULL},
	 { "vectorpairunsigned_front", _wrap_vectorpairunsigned_front, METH_O, NULL},
	 { "vectorpairunsigned_back", _wrap_vectorpairunsigned_back, METH_O, NULL},
	 { "vectorpairunsigned_assign", _wrap_vectorpairunsigned_assign, METH_VARARGS, NULL},
	 { "vectorpairunsigned_resize", _wrap_vectorpairunsigned_resize, METH_VARARGS, NULL},
	 { "vectorpairunsigned_insert", _wrap_vectorpairunsigned_insert, METH_VARARGS, NULL},
	 { "vectorpairunsigned_reserve", _wrap_vectorpairunsigned_reserve, METH_VARARGS, NULL},
	 { "vectorpairunsigned_capacity", _wrap_vectorpairunsigned_capacity, METH_O, NULL},
	 { "delete_vectorpairunsigned", _wrap_delete_vectorpairunsigned, METH_O, NULL},
	 { "vectorpairunsigned_swigregister", vectorpairunsigned_swigregister, METH_O, NULL},
	 { "vectorpairunsigned_swiginit", vectorpairunsigned_swiginit, METH_VARARGS, NULL},
	 { "vectoracccond_iterator", _wrap_vectoracccond_iterator, METH_O, NULL},
	 { "vectoracccond___nonzero__", _wrap_vectoracccond___nonzero__, METH_O, NULL},
	 { "vectoracccond___bool__", _wrap_vectoracccond___bool__, METH_O, NULL},
	 { "vectoracccond___len__", _wrap_vectoracccond___len__, METH_O, NULL},
	 { "vectoracccond___getslice__", _wrap_vectoracccond___getslice__, METH_VARARGS, NULL},
	 { "vectoracccond___setslice__", _wrap_vectoracccond___setslice__, METH_VARARGS, NULL},
	 { "vectoracccond___delslice__", _wrap_vectoracccond___delslice__, METH_VARARGS, NULL},
	 { "vectoracccond___delitem__", _wrap_vectoracccond___delitem__, METH_VARARGS, NULL},
	 { "vectoracccond___getitem__", _wrap_vectoracccond___getitem__, METH_VARARGS, NULL},
	 { "vectoracccond___setitem__", _wrap_vectoracccond___setitem__, METH_VARARGS, NULL},
	 { "vectoracccond_pop", _wrap_vectoracccond_pop, METH_O, NULL},
	 { "vectoracccond_append", _wrap_vectoracccond_append, METH_VARARGS, NULL},
	 { "vectoracccond_empty", _wrap_vectoracccond_empty, METH_O, NULL},
	 { "vectoracccond_size", _wrap_vectoracccond_size, METH_O, NULL},
	 { "vectoracccond_swap", _wrap_vectoracccond_swap, METH_VARARGS, NULL},
	 { "vectoracccond_begin", _wrap_vectoracccond_begin, METH_O, NULL},
	 { "vectoracccond_end", _wrap_vectoracccond_end, METH_O, NULL},
	 { "vectoracccond_rbegin", _wrap_vectoracccond_rbegin, METH_O, NULL},
	 { "vectoracccond_rend", _wrap_vectoracccond_rend, METH_O, NULL},
	 { "vectoracccond_clear", _wrap_vectoracccond_clear, METH_O, NULL},
	 { "vectoracccond_get_allocator", _wrap_vectoracccond_get_allocator, METH_O, NULL},
	 { "vectoracccond_pop_back", _wrap_vectoracccond_pop_back, METH_O, NULL},
	 { "vectoracccond_erase", _wrap_vectoracccond_erase, METH_VARARGS, NULL},
	 { "new_vectoracccond", _wrap_new_vectoracccond, METH_VARARGS, NULL},
	 { "vectoracccond_push_back", _wrap_vectoracccond_push_back, METH_VARARGS, NULL},
	 { "vectoracccond_front", _wrap_vectoracccond_front, METH_O, NULL},
	 { "vectoracccond_back", _wrap_vectoracccond_back, METH_O, NULL},
	 { "vectoracccond_assign", _wrap_vectoracccond_assign, METH_VARARGS, NULL},
	 { "vectoracccond_resize", _wrap_vectoracccond_resize, METH_VARARGS, NULL},
	 { "vectoracccond_insert", _wrap_vectoracccond_insert, METH_VARARGS, NULL},
	 { "vectoracccond_reserve", _wrap_vectoracccond_reserve, METH_VARARGS, NULL},
	 { "vectoracccond_capacity", _wrap_vectoracccond_capacity, METH_O, NULL},
	 { "delete_vectoracccond", _wrap_delete_vectoracccond, METH_O, NULL},
	 { "vectoracccond_swigregister", vectoracccond_swigregister, METH_O, NULL},
	 { "vectoracccond_swiginit", vectoracccond_swiginit, METH_VARARGS, NULL},
	 { "vectoracccode_iterator", _wrap_vectoracccode_iterator, METH_O, NULL},
	 { "vectoracccode___nonzero__", _wrap_vectoracccode___nonzero__, METH_O, NULL},
	 { "vectoracccode___bool__", _wrap_vectoracccode___bool__, METH_O, NULL},
	 { "vectoracccode___len__", _wrap_vectoracccode___len__, METH_O, NULL},
	 { "vectoracccode___getslice__", _wrap_vectoracccode___getslice__, METH_VARARGS, NULL},
	 { "vectoracccode___setslice__", _wrap_vectoracccode___setslice__, METH_VARARGS, NULL},
	 { "vectoracccode___delslice__", _wrap_vectoracccode___delslice__, METH_VARARGS, NULL},
	 { "vectoracccode___delitem__", _wrap_vectoracccode___delitem__, METH_VARARGS, NULL},
	 { "vectoracccode___getitem__", _wrap_vectoracccode___getitem__, METH_VARARGS, NULL},
	 { "vectoracccode___setitem__", _wrap_vectoracccode___setitem__, METH_VARARGS, NULL},
	 { "vectoracccode_pop", _wrap_vectoracccode_pop, METH_O, NULL},
	 { "vectoracccode_append", _wrap_vectoracccode_append, METH_VARARGS, NULL},
	 { "vectoracccode_empty", _wrap_vectoracccode_empty, METH_O, NULL},
	 { "vectoracccode_size", _wrap_vectoracccode_size, METH_O, NULL},
	 { "vectoracccode_swap", _wrap_vectoracccode_swap, METH_VARARGS, NULL},
	 { "vectoracccode_begin", _wrap_vectoracccode_begin, METH_O, NULL},
	 { "vectoracccode_end", _wrap_vectoracccode_end, METH_O, NULL},
	 { "vectoracccode_rbegin", _wrap_vectoracccode_rbegin, METH_O, NULL},
	 { "vectoracccode_rend", _wrap_vectoracccode_rend, METH_O, NULL},
	 { "vectoracccode_clear", _wrap_vectoracccode_clear, METH_O, NULL},
	 { "vectoracccode_get_allocator", _wrap_vectoracccode_get_allocator, METH_O, NULL},
	 { "vectoracccode_pop_back", _wrap_vectoracccode_pop_back, METH_O, NULL},
	 { "vectoracccode_erase", _wrap_vectoracccode_erase, METH_VARARGS, NULL},
	 { "new_vectoracccode", _wrap_new_vectoracccode, METH_VARARGS, NULL},
	 { "vectoracccode_push_back", _wrap_vectoracccode_push_back, METH_VARARGS, NULL},
	 { "vectoracccode_front", _wrap_vectoracccode_front, METH_O, NULL},
	 { "vectoracccode_back", _wrap_vectoracccode_back, METH_O, NULL},
	 { "vectoracccode_assign", _wrap_vectoracccode_assign, METH_VARARGS, NULL},
	 { "vectoracccode_resize", _wrap_vectoracccode_resize, METH_VARARGS, NULL},
	 { "vectoracccode_insert", _wrap_vectoracccode_insert, METH_VARARGS, NULL},
	 { "vectoracccode_reserve", _wrap_vectoracccode_reserve, METH_VARARGS, NULL},
	 { "vectoracccode_capacity", _wrap_vectoracccode_capacity, METH_O, NULL},
	 { "delete_vectoracccode", _wrap_delete_vectoracccode, METH_O, NULL},
	 { "vectoracccode_swigregister", vectoracccode_swigregister, METH_O, NULL},
	 { "vectoracccode_swiginit", vectoracccode_swiginit, METH_VARARGS, NULL},
	 { "vectorbool_iterator", _wrap_vectorbool_iterator, METH_O, NULL},
	 { "vectorbool___nonzero__", _wrap_vectorbool___nonzero__, METH_O, NULL},
	 { "vectorbool___bool__", _wrap_vectorbool___bool__, METH_O, NULL},
	 { "vectorbool___len__", _wrap_vectorbool___len__, METH_O, NULL},
	 { "vectorbool___getslice__", _wrap_vectorbool___getslice__, METH_VARARGS, NULL},
	 { "vectorbool___setslice__", _wrap_vectorbool___setslice__, METH_VARARGS, NULL},
	 { "vectorbool___delslice__", _wrap_vectorbool___delslice__, METH_VARARGS, NULL},
	 { "vectorbool___delitem__", _wrap_vectorbool___delitem__, METH_VARARGS, NULL},
	 { "vectorbool___getitem__", _wrap_vectorbool___getitem__, METH_VARARGS, NULL},
	 { "vectorbool___setitem__", _wrap_vectorbool___setitem__, METH_VARARGS, NULL},
	 { "vectorbool_pop", _wrap_vectorbool_pop, METH_O, NULL},
	 { "vectorbool_append", _wrap_vectorbool_append, METH_VARARGS, NULL},
	 { "vectorbool_empty", _wrap_vectorbool_empty, METH_O, NULL},
	 { "vectorbool_size", _wrap_vectorbool_size, METH_O, NULL},
	 { "vectorbool_swap", _wrap_vectorbool_swap, METH_VARARGS, NULL},
	 { "vectorbool_begin", _wrap_vectorbool_begin, METH_O, NULL},
	 { "vectorbool_end", _wrap_vectorbool_end, METH_O, NULL},
	 { "vectorbool_rbegin", _wrap_vectorbool_rbegin, METH_O, NULL},
	 { "vectorbool_rend", _wrap_vectorbool_rend, METH_O, NULL},
	 { "vectorbool_clear", _wrap_vectorbool_clear, METH_O, NULL},
	 { "vectorbool_get_allocator", _wrap_vectorbool_get_allocator, METH_O, NULL},
	 { "vectorbool_pop_back", _wrap_vectorbool_pop_back, METH_O, NULL},
	 { "vectorbool_erase", _wrap_vectorbool_erase, METH_VARARGS, NULL},
	 { "new_vectorbool", _wrap_new_vectorbool, METH_VARARGS, NULL},
	 { "vectorbool_push_back", _wrap_vectorbool_push_back, METH_VARARGS, NULL},
	 { "vectorbool_front", _wrap_vectorbool_front, METH_O, NULL},
	 { "vectorbool_back", _wrap_vectorbool_back, METH_O, NULL},
	 { "vectorbool_assign", _wrap_vectorbool_assign, METH_VARARGS, NULL},
	 { "vectorbool_resize", _wrap_vectorbool_resize, METH_VARARGS, NULL},
	 { "vectorbool_insert", _wrap_vectorbool_insert, METH_VARARGS, NULL},
	 { "vectorbool_reserve", _wrap_vectorbool_reserve, METH_VARARGS, NULL},
	 { "vectorbool_capacity", _wrap_vectorbool_capacity, METH_O, NULL},
	 { "delete_vectorbool", _wrap_delete_vectorbool, METH_O, NULL},
	 { "vectorbool_swigregister", vectorbool_swigregister, METH_O, NULL},
	 { "vectorbool_swiginit", vectorbool_swiginit, METH_VARARGS, NULL},
	 { "vectorbdd_iterator", _wrap_vectorbdd_iterator, METH_O, NULL},
	 { "vectorbdd___nonzero__", _wrap_vectorbdd___nonzero__, METH_O, NULL},
	 { "vectorbdd___bool__", _wrap_vectorbdd___bool__, METH_O, NULL},
	 { "vectorbdd___len__", _wrap_vectorbdd___len__, METH_O, NULL},
	 { "vectorbdd___getslice__", _wrap_vectorbdd___getslice__, METH_VARARGS, NULL},
	 { "vectorbdd___setslice__", _wrap_vectorbdd___setslice__, METH_VARARGS, NULL},
	 { "vectorbdd___delslice__", _wrap_vectorbdd___delslice__, METH_VARARGS, NULL},
	 { "vectorbdd___delitem__", _wrap_vectorbdd___delitem__, METH_VARARGS, NULL},
	 { "vectorbdd___getitem__", _wrap_vectorbdd___getitem__, METH_VARARGS, NULL},
	 { "vectorbdd___setitem__", _wrap_vectorbdd___setitem__, METH_VARARGS, NULL},
	 { "vectorbdd_pop", _wrap_vectorbdd_pop, METH_O, NULL},
	 { "vectorbdd_append", _wrap_vectorbdd_append, METH_VARARGS, NULL},
	 { "vectorbdd_empty", _wrap_vectorbdd_empty, METH_O, NULL},
	 { "vectorbdd_size", _wrap_vectorbdd_size, METH_O, NULL},
	 { "vectorbdd_swap", _wrap_vectorbdd_swap, METH_VARARGS, NULL},
	 { "vectorbdd_begin", _wrap_vectorbdd_begin, METH_O, NULL},
	 { "vectorbdd_end", _wrap_vectorbdd_end, METH_O, NULL},
	 { "vectorbdd_rbegin", _wrap_vectorbdd_rbegin, METH_O, NULL},
	 { "vectorbdd_rend", _wrap_vectorbdd_rend, METH_O, NULL},
	 { "vectorbdd_clear", _wrap_vectorbdd_clear, METH_O, NULL},
	 { "vectorbdd_get_allocator", _wrap_vectorbdd_get_allocator, METH_O, NULL},
	 { "vectorbdd_pop_back", _wrap_vectorbdd_pop_back, METH_O, NULL},
	 { "vectorbdd_erase", _wrap_vectorbdd_erase, METH_VARARGS, NULL},
	 { "new_vectorbdd", _wrap_new_vectorbdd, METH_VARARGS, NULL},
	 { "vectorbdd_push_back", _wrap_vectorbdd_push_back, METH_VARARGS, NULL},
	 { "vectorbdd_front", _wrap_vectorbdd_front, METH_O, NULL},
	 { "vectorbdd_back", _wrap_vectorbdd_back, METH_O, NULL},
	 { "vectorbdd_assign", _wrap_vectorbdd_assign, METH_VARARGS, NULL},
	 { "vectorbdd_resize", _wrap_vectorbdd_resize, METH_VARARGS, NULL},
	 { "vectorbdd_insert", _wrap_vectorbdd_insert, METH_VARARGS, NULL},
	 { "vectorbdd_reserve", _wrap_vectorbdd_reserve, METH_VARARGS, NULL},
	 { "vectorbdd_capacity", _wrap_vectorbdd_capacity, METH_O, NULL},
	 { "delete_vectorbdd", _wrap_delete_vectorbdd, METH_O, NULL},
	 { "vectorbdd_swigregister", vectorbdd_swigregister, METH_O, NULL},
	 { "vectorbdd_swiginit", vectorbdd_swiginit, METH_VARARGS, NULL},
	 { "aliasvector_iterator", _wrap_aliasvector_iterator, METH_O, NULL},
	 { "aliasvector___nonzero__", _wrap_aliasvector___nonzero__, METH_O, NULL},
	 { "aliasvector___bool__", _wrap_aliasvector___bool__, METH_O, NULL},
	 { "aliasvector___len__", _wrap_aliasvector___len__, METH_O, NULL},
	 { "aliasvector___getslice__", _wrap_aliasvector___getslice__, METH_VARARGS, NULL},
	 { "aliasvector___setslice__", _wrap_aliasvector___setslice__, METH_VARARGS, NULL},
	 { "aliasvector___delslice__", _wrap_aliasvector___delslice__, METH_VARARGS, NULL},
	 { "aliasvector___delitem__", _wrap_aliasvector___delitem__, METH_VARARGS, NULL},
	 { "aliasvector___getitem__", _wrap_aliasvector___getitem__, METH_VARARGS, NULL},
	 { "aliasvector___setitem__", _wrap_aliasvector___setitem__, METH_VARARGS, NULL},
	 { "aliasvector_pop", _wrap_aliasvector_pop, METH_O, NULL},
	 { "aliasvector_append", _wrap_aliasvector_append, METH_VARARGS, NULL},
	 { "aliasvector_empty", _wrap_aliasvector_empty, METH_O, NULL},
	 { "aliasvector_size", _wrap_aliasvector_size, METH_O, NULL},
	 { "aliasvector_swap", _wrap_aliasvector_swap, METH_VARARGS, NULL},
	 { "aliasvector_begin", _wrap_aliasvector_begin, METH_O, NULL},
	 { "aliasvector_end", _wrap_aliasvector_end, METH_O, NULL},
	 { "aliasvector_rbegin", _wrap_aliasvector_rbegin, METH_O, NULL},
	 { "aliasvector_rend", _wrap_aliasvector_rend, METH_O, NULL},
	 { "aliasvector_clear", _wrap_aliasvector_clear, METH_O, NULL},
	 { "aliasvector_get_allocator", _wrap_aliasvector_get_allocator, METH_O, NULL},
	 { "aliasvector_pop_back", _wrap_aliasvector_pop_back, METH_O, NULL},
	 { "aliasvector_erase", _wrap_aliasvector_erase, METH_VARARGS, NULL},
	 { "new_aliasvector", _wrap_new_aliasvector, METH_VARARGS, NULL},
	 { "aliasvector_push_back", _wrap_aliasvector_push_back, METH_VARARGS, NULL},
	 { "aliasvector_front", _wrap_aliasvector_front, METH_O, NULL},
	 { "aliasvector_back", _wrap_aliasvector_back, METH_O, NULL},
	 { "aliasvector_assign", _wrap_aliasvector_assign, METH_VARARGS, NULL},
	 { "aliasvector_resize", _wrap_aliasvector_resize, METH_VARARGS, NULL},
	 { "aliasvector_insert", _wrap_aliasvector_insert, METH_VARARGS, NULL},
	 { "aliasvector_reserve", _wrap_aliasvector_reserve, METH_VARARGS, NULL},
	 { "aliasvector_capacity", _wrap_aliasvector_capacity, METH_O, NULL},
	 { "delete_aliasvector", _wrap_delete_aliasvector, METH_O, NULL},
	 { "aliasvector_swigregister", aliasvector_swigregister, METH_O, NULL},
	 { "aliasvector_swiginit", aliasvector_swiginit, METH_VARARGS, NULL},
	 { "vectorstring_iterator", _wrap_vectorstring_iterator, METH_O, NULL},
	 { "vectorstring___nonzero__", _wrap_vectorstring___nonzero__, METH_O, NULL},
	 { "vectorstring___bool__", _wrap_vectorstring___bool__, METH_O, NULL},
	 { "vectorstring___len__", _wrap_vectorstring___len__, METH_O, NULL},
	 { "vectorstring___getslice__", _wrap_vectorstring___getslice__, METH_VARARGS, NULL},
	 { "vectorstring___setslice__", _wrap_vectorstring___setslice__, METH_VARARGS, NULL},
	 { "vectorstring___delslice__", _wrap_vectorstring___delslice__, METH_VARARGS, NULL},
	 { "vectorstring___delitem__", _wrap_vectorstring___delitem__, METH_VARARGS, NULL},
	 { "vectorstring___getitem__", _wrap_vectorstring___getitem__, METH_VARARGS, NULL},
	 { "vectorstring___setitem__", _wrap_vectorstring___setitem__, METH_VARARGS, NULL},
	 { "vectorstring_pop", _wrap_vectorstring_pop, METH_O, NULL},
	 { "vectorstring_append", _wrap_vectorstring_append, METH_VARARGS, NULL},
	 { "vectorstring_empty", _wrap_vectorstring_empty, METH_O, NULL},
	 { "vectorstring_size", _wrap_vectorstring_size, METH_O, NULL},
	 { "vectorstring_swap", _wrap_vectorstring_swap, METH_VARARGS, NULL},
	 { "vectorstring_begin", _wrap_vectorstring_begin, METH_O, NULL},
	 { "vectorstring_end", _wrap_vectorstring_end, METH_O, NULL},
	 { "vectorstring_rbegin", _wrap_vectorstring_rbegin, METH_O, NULL},
	 { "vectorstring_rend", _wrap_vectorstring_rend, METH_O, NULL},
	 { "vectorstring_clear", _wrap_vectorstring_clear, METH_O, NULL},
	 { "vectorstring_get_allocator", _wrap_vectorstring_get_allocator, METH_O, NULL},
	 { "vectorstring_pop_back", _wrap_vectorstring_pop_back, METH_O, NULL},
	 { "vectorstring_erase", _wrap_vectorstring_erase, METH_VARARGS, NULL},
	 { "new_vectorstring", _wrap_new_vectorstring, METH_VARARGS, NULL},
	 { "vectorstring_push_back", _wrap_vectorstring_push_back, METH_VARARGS, NULL},
	 { "vectorstring_front", _wrap_vectorstring_front, METH_O, NULL},
	 { "vectorstring_back", _wrap_vectorstring_back, METH_O, NULL},
	 { "vectorstring_assign", _wrap_vectorstring_assign, METH_VARARGS, NULL},
	 { "vectorstring_resize", _wrap_vectorstring_resize, METH_VARARGS, NULL},
	 { "vectorstring_insert", _wrap_vectorstring_insert, METH_VARARGS, NULL},
	 { "vectorstring_reserve", _wrap_vectorstring_reserve, METH_VARARGS, NULL},
	 { "vectorstring_capacity", _wrap_vectorstring_capacity, METH_O, NULL},
	 { "delete_vectorstring", _wrap_delete_vectorstring, METH_O, NULL},
	 { "vectorstring_swigregister", vectorstring_swigregister, METH_O, NULL},
	 { "vectorstring_swiginit", vectorstring_swiginit, METH_VARARGS, NULL},
	 { "vectorint_iterator", _wrap_vectorint_iterator, METH_O, NULL},
	 { "vectorint___nonzero__", _wrap_vectorint___nonzero__, METH_O, NULL},
	 { "vectorint___bool__", _wrap_vectorint___bool__, METH_O, NULL},
	 { "vectorint___len__", _wrap_vectorint___len__, METH_O, NULL},
	 { "vectorint___getslice__", _wrap_vectorint___getslice__, METH_VARARGS, NULL},
	 { "vectorint___setslice__", _wrap_vectorint___setslice__, METH_VARARGS, NULL},
	 { "vectorint___delslice__", _wrap_vectorint___delslice__, METH_VARARGS, NULL},
	 { "vectorint___delitem__", _wrap_vectorint___delitem__, METH_VARARGS, NULL},
	 { "vectorint___getitem__", _wrap_vectorint___getitem__, METH_VARARGS, NULL},
	 { "vectorint___setitem__", _wrap_vectorint___setitem__, METH_VARARGS, NULL},
	 { "vectorint_pop", _wrap_vectorint_pop, METH_O, NULL},
	 { "vectorint_append", _wrap_vectorint_append, METH_VARARGS, NULL},
	 { "vectorint_empty", _wrap_vectorint_empty, METH_O, NULL},
	 { "vectorint_size", _wrap_vectorint_size, METH_O, NULL},
	 { "vectorint_swap", _wrap_vectorint_swap, METH_VARARGS, NULL},
	 { "vectorint_begin", _wrap_vectorint_begin, METH_O, NULL},
	 { "vectorint_end", _wrap_vectorint_end, METH_O, NULL},
	 { "vectorint_rbegin", _wrap_vectorint_rbegin, METH_O, NULL},
	 { "vectorint_rend", _wrap_vectorint_rend, METH_O, NULL},
	 { "vectorint_clear", _wrap_vectorint_clear, METH_O, NULL},
	 { "vectorint_get_allocator", _wrap_vectorint_get_allocator, METH_O, NULL},
	 { "vectorint_pop_back", _wrap_vectorint_pop_back, METH_O, NULL},
	 { "vectorint_erase", _wrap_vectorint_erase, METH_VARARGS, NULL},
	 { "new_vectorint", _wrap_new_vectorint, METH_VARARGS, NULL},
	 { "vectorint_push_back", _wrap_vectorint_push_back, METH_VARARGS, NULL},
	 { "vectorint_front", _wrap_vectorint_front, METH_O, NULL},
	 { "vectorint_back", _wrap_vectorint_back, METH_O, NULL},
	 { "vectorint_assign", _wrap_vectorint_assign, METH_VARARGS, NULL},
	 { "vectorint_resize", _wrap_vectorint_resize, METH_VARARGS, NULL},
	 { "vectorint_insert", _wrap_vectorint_insert, METH_VARARGS, NULL},
	 { "vectorint_reserve", _wrap_vectorint_reserve, METH_VARARGS, NULL},
	 { "vectorint_capacity", _wrap_vectorint_capacity, METH_O, NULL},
	 { "delete_vectorint", _wrap_delete_vectorint, METH_O, NULL},
	 { "vectorint_swigregister", vectorint_swigregister, METH_O, NULL},
	 { "vectorint_swiginit", vectorint_swiginit, METH_VARARGS, NULL},
	 { "new_pair_formula_vectorstring", _wrap_new_pair_formula_vectorstring, METH_VARARGS, NULL},
	 { "pair_formula_vectorstring_first_set", _wrap_pair_formula_vectorstring_first_set, METH_VARARGS, NULL},
	 { "pair_formula_vectorstring_first_get", _wrap_pair_formula_vectorstring_first_get, METH_O, NULL},
	 { "pair_formula_vectorstring_second_set", _wrap_pair_formula_vectorstring_second_set, METH_VARARGS, NULL},
	 { "pair_formula_vectorstring_second_get", _wrap_pair_formula_vectorstring_second_get, METH_O, NULL},
	 { "delete_pair_formula_vectorstring", _wrap_delete_pair_formula_vectorstring, METH_O, NULL},
	 { "pair_formula_vectorstring_swigregister", pair_formula_vectorstring_swigregister, METH_O, NULL},
	 { "pair_formula_vectorstring_swiginit", pair_formula_vectorstring_swiginit, METH_VARARGS, NULL},
	 { "atomic_prop_set_iterator", _wrap_atomic_prop_set_iterator, METH_O, NULL},
	 { "atomic_prop_set___nonzero__", _wrap_atomic_prop_set___nonzero__, METH_O, NULL},
	 { "atomic_prop_set___bool__", _wrap_atomic_prop_set___bool__, METH_O, NULL},
	 { "atomic_prop_set___len__", _wrap_atomic_prop_set___len__, METH_O, NULL},
	 { "atomic_prop_set_append", _wrap_atomic_prop_set_append, METH_VARARGS, NULL},
	 { "atomic_prop_set___contains__", _wrap_atomic_prop_set___contains__, METH_VARARGS, NULL},
	 { "atomic_prop_set___getitem__", _wrap_atomic_prop_set___getitem__, METH_VARARGS, NULL},
	 { "atomic_prop_set_add", _wrap_atomic_prop_set_add, METH_VARARGS, NULL},
	 { "atomic_prop_set_discard", _wrap_atomic_prop_set_discard, METH_VARARGS, NULL},
	 { "new_atomic_prop_set", _wrap_new_atomic_prop_set, METH_VARARGS, NULL},
	 { "atomic_prop_set_empty", _wrap_atomic_prop_set_empty, METH_O, NULL},
	 { "atomic_prop_set_size", _wrap_atomic_prop_set_size, METH_O, NULL},
	 { "atomic_prop_set_clear", _wrap_atomic_prop_set_clear, METH_O, NULL},
	 { "atomic_prop_set_swap", _wrap_atomic_prop_set_swap, METH_VARARGS, NULL},
	 { "atomic_prop_set_count", _wrap_atomic_prop_set_count, METH_VARARGS, NULL},
	 { "atomic_prop_set_begin", _wrap_atomic_prop_set_begin, METH_O, NULL},
	 { "atomic_prop_set_end", _wrap_atomic_prop_set_end, METH_O, NULL},
	 { "atomic_prop_set_rbegin", _wrap_atomic_prop_set_rbegin, METH_O, NULL},
	 { "atomic_prop_set_rend", _wrap_atomic_prop_set_rend, METH_O, NULL},
	 { "atomic_prop_set_erase", _wrap_atomic_prop_set_erase, METH_VARARGS, NULL},
	 { "atomic_prop_set_find", _wrap_atomic_prop_set_find, METH_VARARGS, NULL},
	 { "atomic_prop_set_lower_bound", _wrap_atomic_prop_set_lower_bound, METH_VARARGS, NULL},
	 { "atomic_prop_set_upper_bound", _wrap_atomic_prop_set_upper_bound, METH_VARARGS, NULL},
	 { "atomic_prop_set_equal_range", _wrap_atomic_prop_set_equal_range, METH_VARARGS, NULL},
	 { "atomic_prop_set_insert", _wrap_atomic_prop_set_insert, METH_VARARGS, NULL},
	 { "atomic_prop_set___str__", _wrap_atomic_prop_set___str__, METH_O, NULL},
	 { "atomic_prop_set___repr__", _wrap_atomic_prop_set___repr__, METH_O, NULL},
	 { "delete_atomic_prop_set", _wrap_delete_atomic_prop_set, METH_O, NULL},
	 { "atomic_prop_set_swigregister", atomic_prop_set_swigregister, METH_O, NULL},
	 { "atomic_prop_set_swiginit", atomic_prop_set_swiginit, METH_VARARGS, NULL},
	 { "relabeling_map_iterator", _wrap_relabeling_map_iterator, METH_O, NULL},
	 { "relabeling_map___nonzero__", _wrap_relabeling_map___nonzero__, METH_O, NULL},
	 { "relabeling_map___bool__", _wrap_relabeling_map___bool__, METH_O, NULL},
	 { "relabeling_map___len__", _wrap_relabeling_map___len__, METH_O, NULL},
	 { "relabeling_map___getitem__", _wrap_relabeling_map___getitem__, METH_VARARGS, NULL},
	 { "relabeling_map___delitem__", _wrap_relabeling_map___delitem__, METH_VARARGS, NULL},
	 { "relabeling_map_has_key", _wrap_relabeling_map_has_key, METH_VARARGS, NULL},
	 { "relabeling_map_keys", _wrap_relabeling_map_keys, METH_O, NULL},
	 { "relabeling_map_values", _wrap_relabeling_map_values, METH_O, NULL},
	 { "relabeling_map_items", _wrap_relabeling_map_items, METH_O, NULL},
	 { "relabeling_map___contains__", _wrap_relabeling_map___contains__, METH_VARARGS, NULL},
	 { "relabeling_map_key_iterator", _wrap_relabeling_map_key_iterator, METH_O, NULL},
	 { "relabeling_map_value_iterator", _wrap_relabeling_map_value_iterator, METH_O, NULL},
	 { "relabeling_map___setitem__", _wrap_relabeling_map___setitem__, METH_VARARGS, NULL},
	 { "relabeling_map_asdict", _wrap_relabeling_map_asdict, METH_O, NULL},
	 { "new_relabeling_map", _wrap_new_relabeling_map, METH_VARARGS, NULL},
	 { "relabeling_map_empty", _wrap_relabeling_map_empty, METH_O, NULL},
	 { "relabeling_map_size", _wrap_relabeling_map_size, METH_O, NULL},
	 { "relabeling_map_swap", _wrap_relabeling_map_swap, METH_VARARGS, NULL},
	 { "relabeling_map_begin", _wrap_relabeling_map_begin, METH_O, NULL},
	 { "relabeling_map_end", _wrap_relabeling_map_end, METH_O, NULL},
	 { "relabeling_map_rbegin", _wrap_relabeling_map_rbegin, METH_O, NULL},
	 { "relabeling_map_rend", _wrap_relabeling_map_rend, METH_O, NULL},
	 { "relabeling_map_clear", _wrap_relabeling_map_clear, METH_O, NULL},
	 { "relabeling_map_get_allocator", _wrap_relabeling_map_get_allocator, METH_O, NULL},
	 { "relabeling_map_count", _wrap_relabeling_map_count, METH_VARARGS, NULL},
	 { "relabeling_map_erase", _wrap_relabeling_map_erase, METH_VARARGS, NULL},
	 { "relabeling_map_find", _wrap_relabeling_map_find, METH_VARARGS, NULL},
	 { "relabeling_map_lower_bound", _wrap_relabeling_map_lower_bound, METH_VARARGS, NULL},
	 { "relabeling_map_upper_bound", _wrap_relabeling_map_upper_bound, METH_VARARGS, NULL},
	 { "delete_relabeling_map", _wrap_delete_relabeling_map, METH_O, NULL},
	 { "relabeling_map_swigregister", relabeling_map_swigregister, METH_O, NULL},
	 { "relabeling_map_swiginit", relabeling_map_swiginit, METH_VARARGS, NULL},
	 { "environment_require", _wrap_environment_require, METH_VARARGS, NULL},
	 { "environment_name", _wrap_environment_name, METH_O, NULL},
	 { "delete_environment", _wrap_delete_environment, METH_O, NULL},
	 { "environment_swigregister", environment_swigregister, METH_O, NULL},
	 { "new_declarative_environment", _wrap_new_declarative_environment, METH_NOARGS, NULL},
	 { "delete_declarative_environment", _wrap_delete_declarative_environment, METH_O, NULL},
	 { "declarative_environment_declare", _wrap_declarative_environment_declare, METH_VARARGS, NULL},
	 { "declarative_environment_get_prop_map", _wrap_declarative_environment_get_prop_map, METH_O, NULL},
	 { "declarative_environment_swigregister", declarative_environment_swigregister, METH_O, NULL},
	 { "declarative_environment_swiginit", declarative_environment_swiginit, METH_VARARGS, NULL},
	 { "delete_default_environment", _wrap_delete_default_environment, METH_O, NULL},
	 { "default_environment_instance", _wrap_default_environment_instance, METH_NOARGS, NULL},
	 { "default_environment_swigregister", default_environment_swigregister, METH_O, NULL},
	 { "parse_error_list___nonzero__", _wrap_parse_error_list___nonzero__, METH_O, NULL},
	 { "parse_error_list___bool__", _wrap_parse_error_list___bool__, METH_O, NULL},
	 { "new_parse_error_list", _wrap_new_parse_error_list, METH_NOARGS, NULL},
	 { "delete_parse_error_list", _wrap_delete_parse_error_list, METH_O, NULL},
	 { "parse_error_list_swigregister", parse_error_list_swigregister, METH_O, NULL},
	 { "parse_error_list_swiginit", parse_error_list_swiginit, METH_VARARGS, NULL},
	 { "parsed_formula_f_set", _wrap_parsed_formula_f_set, METH_VARARGS, NULL},
	 { "parsed_formula_f_get", _wrap_parsed_formula_f_get, METH_O, NULL},
	 { "parsed_formula_input_set", _wrap_parsed_formula_input_set, METH_VARARGS, NULL},
	 { "parsed_formula_input_get", _wrap_parsed_formula_input_get, METH_O, NULL},
	 { "parsed_formula_errors_set", _wrap_parsed_formula_errors_set, METH_VARARGS, NULL},
	 { "parsed_formula_errors_get", _wrap_parsed_formula_errors_get, METH_O, NULL},
	 { "new_parsed_formula", _wrap_new_parsed_formula, METH_VARARGS, NULL},
	 { "parsed_formula_format_errors", _wrap_parsed_formula_format_errors, METH_VARARGS, NULL},
	 { "delete_parsed_formula", _wrap_delete_parsed_formula, METH_O, NULL},
	 { "parsed_formula_swigregister", parsed_formula_swigregister, METH_O, NULL},
	 { "parsed_formula_swiginit", parsed_formula_swiginit, METH_VARARGS, NULL},
	 { "parse_infix_psl", _wrap_parse_infix_psl, METH_VARARGS, NULL},
	 { "parse_infix_boolean", _wrap_parse_infix_boolean, METH_VARARGS, NULL},
	 { "parse_prefix_ltl", _wrap_parse_prefix_ltl, METH_VARARGS, NULL},
	 { "parse_formula", _wrap_parse_formula, METH_VARARGS, NULL},
	 { "parse_infix_sere", _wrap_parse_infix_sere, METH_VARARGS, NULL},
	 { "fix_utf8_locations", _wrap_fix_utf8_locations, METH_VARARGS, NULL},
	 { "new_bdd_dict", _wrap_new_bdd_dict, METH_NOARGS, NULL},
	 { "delete_bdd_dict", _wrap_delete_bdd_dict, METH_O, NULL},
	 { "bdd_dict_var_map_set", _wrap_bdd_dict_var_map_set, METH_VARARGS, NULL},
	 { "bdd_dict_var_map_get", _wrap_bdd_dict_var_map_get, METH_O, NULL},
	 { "bdd_dict_acc_map_set", _wrap_bdd_dict_acc_map_set, METH_VARARGS, NULL},
	 { "bdd_dict_acc_map_get", _wrap_bdd_dict_acc_map_get, METH_O, NULL},
	 { "bdd_dict_bdd_map_set", _wrap_bdd_dict_bdd_map_set, METH_VARARGS, NULL},
	 { "bdd_dict_bdd_map_get", _wrap_bdd_dict_bdd_map_get, METH_O, NULL},
	 { "bdd_dict_has_registered_proposition", _wrap_bdd_dict_has_registered_proposition, METH_VARARGS, NULL},
	 { "bdd_dict_varnum", _wrap_bdd_dict_varnum, METH_VARARGS, NULL},
	 { "bdd_dict_register_acceptance_variable", _wrap_bdd_dict_register_acceptance_variable, METH_VARARGS, NULL},
	 { "bdd_dict_dump", _wrap_bdd_dict_dump, METH_VARARGS, NULL},
	 { "bdd_dict_assert_emptiness", _wrap_bdd_dict_assert_emptiness, METH_O, NULL},
	 { "bdd_dict___eq__", _wrap_bdd_dict___eq__, METH_VARARGS, NULL},
	 { "bdd_dict___ne__", _wrap_bdd_dict___ne__, METH_VARARGS, NULL},
	 { "bdd_dict_register_proposition", _wrap_bdd_dict_register_proposition, METH_VARARGS, NULL},
	 { "bdd_dict_unregister_all_my_variables", _wrap_bdd_dict_unregister_all_my_variables, METH_VARARGS, NULL},
	 { "bdd_dict_unregister_variable", _wrap_bdd_dict_unregister_variable, METH_VARARGS, NULL},
	 { "bdd_dict_register_all_variables_of", _wrap_bdd_dict_register_all_variables_of, METH_VARARGS, NULL},
	 { "bdd_dict_register_anonymous_variables", _wrap_bdd_dict_register_anonymous_variables, METH_VARARGS, NULL},
	 { "bdd_dict_swigregister", bdd_dict_swigregister, METH_O, NULL},
	 { "bdd_dict_swiginit", bdd_dict_swiginit, METH_VARARGS, NULL},
	 { "make_bdd_dict", _wrap_make_bdd_dict, METH_NOARGS, NULL},
	 { "bdd_print_sat", _wrap_bdd_print_sat, METH_VARARGS, NULL},
	 { "bdd_format_sat", _wrap_bdd_format_sat, METH_VARARGS, NULL},
	 { "bdd_print_accset", _wrap_bdd_print_accset, METH_VARARGS, NULL},
	 { "bdd_format_accset", _wrap_bdd_format_accset, METH_VARARGS, NULL},
	 { "bdd_print_set", _wrap_bdd_print_set, METH_VARARGS, NULL},
	 { "bdd_format_set", _wrap_bdd_format_set, METH_VARARGS, NULL},
	 { "bdd_print_formula", _wrap_bdd_print_formula, METH_VARARGS, NULL},
	 { "bdd_format_formula", _wrap_bdd_format_formula, METH_VARARGS, NULL},
	 { "enable_utf8", _wrap_enable_utf8, METH_NOARGS, NULL},
	 { "bdd_format_isop", _wrap_bdd_format_isop, METH_VARARGS, NULL},
	 { "bdd_print_isop", _wrap_bdd_print_isop, METH_VARARGS, NULL},
	 { "bdd_to_formula", _wrap_bdd_to_formula, METH_VARARGS, NULL},
	 { "formula_to_bdd", _wrap_formula_to_bdd, METH_VARARGS, NULL},
	 { "vector_rs_pair_iterator", _wrap_vector_rs_pair_iterator, METH_O, NULL},
	 { "vector_rs_pair___nonzero__", _wrap_vector_rs_pair___nonzero__, METH_O, NULL},
	 { "vector_rs_pair___bool__", _wrap_vector_rs_pair___bool__, METH_O, NULL},
	 { "vector_rs_pair___len__", _wrap_vector_rs_pair___len__, METH_O, NULL},
	 { "vector_rs_pair___getslice__", _wrap_vector_rs_pair___getslice__, METH_VARARGS, NULL},
	 { "vector_rs_pair___setslice__", _wrap_vector_rs_pair___setslice__, METH_VARARGS, NULL},
	 { "vector_rs_pair___delslice__", _wrap_vector_rs_pair___delslice__, METH_VARARGS, NULL},
	 { "vector_rs_pair___delitem__", _wrap_vector_rs_pair___delitem__, METH_VARARGS, NULL},
	 { "vector_rs_pair___getitem__", _wrap_vector_rs_pair___getitem__, METH_VARARGS, NULL},
	 { "vector_rs_pair___setitem__", _wrap_vector_rs_pair___setitem__, METH_VARARGS, NULL},
	 { "vector_rs_pair_pop", _wrap_vector_rs_pair_pop, METH_O, NULL},
	 { "vector_rs_pair_append", _wrap_vector_rs_pair_append, METH_VARARGS, NULL},
	 { "vector_rs_pair_empty", _wrap_vector_rs_pair_empty, METH_O, NULL},
	 { "vector_rs_pair_size", _wrap_vector_rs_pair_size, METH_O, NULL},
	 { "vector_rs_pair_swap", _wrap_vector_rs_pair_swap, METH_VARARGS, NULL},
	 { "vector_rs_pair_begin", _wrap_vector_rs_pair_begin, METH_O, NULL},
	 { "vector_rs_pair_end", _wrap_vector_rs_pair_end, METH_O, NULL},
	 { "vector_rs_pair_rbegin", _wrap_vector_rs_pair_rbegin, METH_O, NULL},
	 { "vector_rs_pair_rend", _wrap_vector_rs_pair_rend, METH_O, NULL},
	 { "vector_rs_pair_clear", _wrap_vector_rs_pair_clear, METH_O, NULL},
	 { "vector_rs_pair_get_allocator", _wrap_vector_rs_pair_get_allocator, METH_O, NULL},
	 { "vector_rs_pair_pop_back", _wrap_vector_rs_pair_pop_back, METH_O, NULL},
	 { "vector_rs_pair_erase", _wrap_vector_rs_pair_erase, METH_VARARGS, NULL},
	 { "new_vector_rs_pair", _wrap_new_vector_rs_pair, METH_VARARGS, NULL},
	 { "vector_rs_pair_push_back", _wrap_vector_rs_pair_push_back, METH_VARARGS, NULL},
	 { "vector_rs_pair_front", _wrap_vector_rs_pair_front, METH_O, NULL},
	 { "vector_rs_pair_back", _wrap_vector_rs_pair_back, METH_O, NULL},
	 { "vector_rs_pair_assign", _wrap_vector_rs_pair_assign, METH_VARARGS, NULL},
	 { "vector_rs_pair_resize", _wrap_vector_rs_pair_resize, METH_VARARGS, NULL},
	 { "vector_rs_pair_insert", _wrap_vector_rs_pair_insert, METH_VARARGS, NULL},
	 { "vector_rs_pair_reserve", _wrap_vector_rs_pair_reserve, METH_VARARGS, NULL},
	 { "vector_rs_pair_capacity", _wrap_vector_rs_pair_capacity, METH_O, NULL},
	 { "delete_vector_rs_pair", _wrap_delete_vector_rs_pair, METH_O, NULL},
	 { "vector_rs_pair_swigregister", vector_rs_pair_swigregister, METH_O, NULL},
	 { "vector_rs_pair_swiginit", vector_rs_pair_swiginit, METH_VARARGS, NULL},
	 { "acc_cond_has_parity_prefix", _wrap_acc_cond_has_parity_prefix, METH_VARARGS, NULL},
	 { "new_acc_cond", _wrap_new_acc_cond, METH_VARARGS, NULL},
	 { "delete_acc_cond", _wrap_delete_acc_cond, METH_O, NULL},
	 { "acc_cond_set_acceptance", _wrap_acc_cond_set_acceptance, METH_VARARGS, NULL},
	 { "acc_cond_get_acceptance", _wrap_acc_cond_get_acceptance, METH_VARARGS, NULL},
	 { "acc_cond___eq__", _wrap_acc_cond___eq__, METH_VARARGS, NULL},
	 { "acc_cond___ne__", _wrap_acc_cond___ne__, METH_VARARGS, NULL},
	 { "acc_cond_uses_fin_acceptance", _wrap_acc_cond_uses_fin_acceptance, METH_O, NULL},
	 { "acc_cond_is_t", _wrap_acc_cond_is_t, METH_O, NULL},
	 { "acc_cond_is_all", _wrap_acc_cond_is_all, METH_O, NULL},
	 { "acc_cond_is_f", _wrap_acc_cond_is_f, METH_O, NULL},
	 { "acc_cond_is_none", _wrap_acc_cond_is_none, METH_O, NULL},
	 { "acc_cond_is_buchi", _wrap_acc_cond_is_buchi, METH_O, NULL},
	 { "acc_cond_is_co_buchi", _wrap_acc_cond_is_co_buchi, METH_O, NULL},
	 { "acc_cond_set_generalized_buchi", _wrap_acc_cond_set_generalized_buchi, METH_O, NULL},
	 { "acc_cond_set_generalized_co_buchi", _wrap_acc_cond_set_generalized_co_buchi, METH_O, NULL},
	 { "acc_cond_is_generalized_buchi", _wrap_acc_cond_is_generalized_buchi, METH_O, NULL},
	 { "acc_cond_is_generalized_co_buchi", _wrap_acc_cond_is_generalized_co_buchi, METH_O, NULL},
	 { "acc_cond_is_rabin", _wrap_acc_cond_is_rabin, METH_O, NULL},
	 { "acc_cond_is_streett", _wrap_acc_cond_is_streett, METH_O, NULL},
	 { "acc_cond_is_streett_like", _wrap_acc_cond_is_streett_like, METH_O, NULL},
	 { "acc_cond_is_rabin_like", _wrap_acc_cond_is_rabin_like, METH_O, NULL},
	 { "acc_cond_is_generalized_rabin", _wrap_acc_cond_is_generalized_rabin, METH_O, NULL},
	 { "acc_cond_is_generalized_streett", _wrap_acc_cond_is_generalized_streett, METH_O, NULL},
	 { "acc_cond_is_parity_max_equiv", _wrap_acc_cond_is_parity_max_equiv, METH_VARARGS, NULL},
	 { "acc_cond_is_parity", _wrap_acc_cond_is_parity, METH_VARARGS, NULL},
	 { "acc_cond_unit_propagation", _wrap_acc_cond_unit_propagation, METH_O, NULL},
	 { "acc_cond_unsat_mark", _wrap_acc_cond_unsat_mark, METH_O, NULL},
	 { "acc_cond_sat_mark", _wrap_acc_cond_sat_mark, METH_O, NULL},
	 { "acc_cond_inf", _wrap_acc_cond_inf, METH_VARARGS, NULL},
	 { "acc_cond_inf_neg", _wrap_acc_cond_inf_neg, METH_VARARGS, NULL},
	 { "acc_cond_fin", _wrap_acc_cond_fin, METH_VARARGS, NULL},
	 { "acc_cond_fin_neg", _wrap_acc_cond_fin_neg, METH_VARARGS, NULL},
	 { "acc_cond_add_sets", _wrap_acc_cond_add_sets, METH_VARARGS, NULL},
	 { "acc_cond_add_set", _wrap_acc_cond_add_set, METH_O, NULL},
	 { "acc_cond_mark", _wrap_acc_cond_mark, METH_VARARGS, NULL},
	 { "acc_cond_comp", _wrap_acc_cond_comp, METH_VARARGS, NULL},
	 { "acc_cond_all_sets", _wrap_acc_cond_all_sets, METH_O, NULL},
	 { "acc_cond_apply_permutation", _wrap_acc_cond_apply_permutation, METH_VARARGS, NULL},
	 { "acc_cond_apply_permutation_aux", _wrap_acc_cond_apply_permutation_aux, METH_VARARGS, NULL},
	 { "acc_cond_accepting", _wrap_acc_cond_accepting, METH_VARARGS, NULL},
	 { "acc_cond_inf_satisfiable", _wrap_acc_cond_inf_satisfiable, METH_VARARGS, NULL},
	 { "acc_cond_maybe_accepting", _wrap_acc_cond_maybe_accepting, METH_VARARGS, NULL},
	 { "acc_cond_accepting_sets", _wrap_acc_cond_accepting_sets, METH_VARARGS, NULL},
	 { "acc_cond_format", _wrap_acc_cond_format, METH_VARARGS, NULL},
	 { "acc_cond_num_sets", _wrap_acc_cond_num_sets, METH_O, NULL},
	 { "acc_cond_remove", _wrap_acc_cond_remove, METH_VARARGS, NULL},
	 { "acc_cond_strip", _wrap_acc_cond_strip, METH_VARARGS, NULL},
	 { "acc_cond_force_inf", _wrap_acc_cond_force_inf, METH_VARARGS, NULL},
	 { "acc_cond_restrict_to", _wrap_acc_cond_restrict_to, METH_VARARGS, NULL},
	 { "acc_cond_name", _wrap_acc_cond_name, METH_VARARGS, NULL},
	 { "acc_cond_fin_unit", _wrap_acc_cond_fin_unit, METH_O, NULL},
	 { "acc_cond_inf_unit", _wrap_acc_cond_inf_unit, METH_O, NULL},
	 { "acc_cond_fin_one", _wrap_acc_cond_fin_one, METH_O, NULL},
	 { "acc_cond_fin_one_extract", _wrap_acc_cond_fin_one_extract, METH_O, NULL},
	 { "acc_cond_fin_unit_one_split", _wrap_acc_cond_fin_unit_one_split, METH_O, NULL},
	 { "acc_cond_top_disjuncts", _wrap_acc_cond_top_disjuncts, METH_O, NULL},
	 { "acc_cond_top_conjuncts", _wrap_acc_cond_top_conjuncts, METH_O, NULL},
	 { "acc_cond___repr__", _wrap_acc_cond___repr__, METH_O, NULL},
	 { "acc_cond___str__", _wrap_acc_cond___str__, METH_O, NULL},
	 { "acc_cond_swigregister", acc_cond_swigregister, METH_O, NULL},
	 { "acc_cond_swiginit", acc_cond_swiginit, METH_VARARGS, NULL},
	 { "mark_t_apply_permutation", _wrap_mark_t_apply_permutation, METH_VARARGS, NULL},
	 { "mark_t_max_accsets", _wrap_mark_t_max_accsets, METH_NOARGS, NULL},
	 { "mark_t_all", _wrap_mark_t_all, METH_NOARGS, NULL},
	 { "mark_t_hash", _wrap_mark_t_hash, METH_O, NULL},
	 { "mark_t___eq__", _wrap_mark_t___eq__, METH_VARARGS, NULL},
	 { "mark_t___ne__", _wrap_mark_t___ne__, METH_VARARGS, NULL},
	 { "mark_t___lt__", _wrap_mark_t___lt__, METH_VARARGS, NULL},
	 { "mark_t___le__", _wrap_mark_t___le__, METH_VARARGS, NULL},
	 { "mark_t___gt__", _wrap_mark_t___gt__, METH_VARARGS, NULL},
	 { "mark_t___ge__", _wrap_mark_t___ge__, METH_VARARGS, NULL},
	 { "mark_t___nonzero__", _wrap_mark_t___nonzero__, METH_O, NULL},
	 { "mark_t_has", _wrap_mark_t_has, METH_VARARGS, NULL},
	 { "mark_t_set", _wrap_mark_t_set, METH_VARARGS, NULL},
	 { "mark_t_clear", _wrap_mark_t_clear, METH_VARARGS, NULL},
	 { "mark_t___iand__", _wrap_mark_t___iand__, METH_VARARGS, NULL},
	 { "mark_t___ior__", _wrap_mark_t___ior__, METH_VARARGS, NULL},
	 { "mark_t___isub__", _wrap_mark_t___isub__, METH_VARARGS, NULL},
	 { "mark_t___ixor__", _wrap_mark_t___ixor__, METH_VARARGS, NULL},
	 { "mark_t___and__", _wrap_mark_t___and__, METH_VARARGS, NULL},
	 { "mark_t___or__", _wrap_mark_t___or__, METH_VARARGS, NULL},
	 { "mark_t___sub__", _wrap_mark_t___sub__, METH_VARARGS, NULL},
	 { "mark_t___invert__", _wrap_mark_t___invert__, METH_O, NULL},
	 { "mark_t___xor__", _wrap_mark_t___xor__, METH_VARARGS, NULL},
	 { "mark_t___lshift__", _wrap_mark_t___lshift__, METH_VARARGS, NULL},
	 { "mark_t___ilshift__", _wrap_mark_t___ilshift__, METH_VARARGS, NULL},
	 { "mark_t___rshift__", _wrap_mark_t___rshift__, METH_VARARGS, NULL},
	 { "mark_t___irshift__", _wrap_mark_t___irshift__, METH_VARARGS, NULL},
	 { "mark_t_strip", _wrap_mark_t_strip, METH_VARARGS, NULL},
	 { "mark_t_subset", _wrap_mark_t_subset, METH_VARARGS, NULL},
	 { "mark_t_proper_subset", _wrap_mark_t_proper_subset, METH_VARARGS, NULL},
	 { "mark_t_count", _wrap_mark_t_count, METH_O, NULL},
	 { "mark_t_max_set", _wrap_mark_t_max_set, METH_O, NULL},
	 { "mark_t_min_set", _wrap_mark_t_min_set, METH_O, NULL},
	 { "mark_t_lowest", _wrap_mark_t_lowest, METH_O, NULL},
	 { "mark_t_is_singleton", _wrap_mark_t_is_singleton, METH_O, NULL},
	 { "mark_t_has_many", _wrap_mark_t_has_many, METH_O, NULL},
	 { "mark_t_remove_some", _wrap_mark_t_remove_some, METH_VARARGS, NULL},
	 { "mark_t_sets", _wrap_mark_t_sets, METH_O, NULL},
	 { "mark_t_as_string", _wrap_mark_t_as_string, METH_O, NULL},
	 { "new_mark_t", _wrap_new_mark_t, METH_VARARGS, NULL},
	 { "mark_t___repr__", _wrap_mark_t___repr__, METH_O, NULL},
	 { "mark_t___str__", _wrap_mark_t___str__, METH_O, NULL},
	 { "delete_mark_t", _wrap_delete_mark_t, METH_O, NULL},
	 { "mark_t_swigregister", mark_t_swigregister, METH_O, NULL},
	 { "mark_t_swiginit", mark_t_swiginit, METH_VARARGS, NULL},
	 { "acc_code_unit_propagation", _wrap_acc_code_unit_propagation, METH_O, NULL},
	 { "acc_code_has_parity_prefix", _wrap_acc_code_has_parity_prefix, METH_VARARGS, NULL},
	 { "acc_code_is_parity_max_equiv", _wrap_acc_code_is_parity_max_equiv, METH_VARARGS, NULL},
	 { "acc_code___eq__", _wrap_acc_code___eq__, METH_VARARGS, NULL},
	 { "acc_code___lt__", _wrap_acc_code___lt__, METH_VARARGS, NULL},
	 { "acc_code___gt__", _wrap_acc_code___gt__, METH_VARARGS, NULL},
	 { "acc_code___le__", _wrap_acc_code___le__, METH_VARARGS, NULL},
	 { "acc_code___ge__", _wrap_acc_code___ge__, METH_VARARGS, NULL},
	 { "acc_code___ne__", _wrap_acc_code___ne__, METH_VARARGS, NULL},
	 { "acc_code_is_t", _wrap_acc_code_is_t, METH_O, NULL},
	 { "acc_code_is_f", _wrap_acc_code_is_f, METH_O, NULL},
	 { "acc_code_f", _wrap_acc_code_f, METH_NOARGS, NULL},
	 { "acc_code_t", _wrap_acc_code_t, METH_NOARGS, NULL},
	 { "acc_code_fin", _wrap_acc_code_fin, METH_VARARGS, NULL},
	 { "acc_code_fin_neg", _wrap_acc_code_fin_neg, METH_VARARGS, NULL},
	 { "acc_code_inf", _wrap_acc_code_inf, METH_VARARGS, NULL},
	 { "acc_code_inf_neg", _wrap_acc_code_inf_neg, METH_VARARGS, NULL},
	 { "acc_code_buchi", _wrap_acc_code_buchi, METH_NOARGS, NULL},
	 { "acc_code_cobuchi", _wrap_acc_code_cobuchi, METH_NOARGS, NULL},
	 { "acc_code_generalized_buchi", _wrap_acc_code_generalized_buchi, METH_O, NULL},
	 { "acc_code_generalized_co_buchi", _wrap_acc_code_generalized_co_buchi, METH_O, NULL},
	 { "acc_code_rabin", _wrap_acc_code_rabin, METH_O, NULL},
	 { "acc_code_streett", _wrap_acc_code_streett, METH_O, NULL},
	 { "acc_code_parity", _wrap_acc_code_parity, METH_VARARGS, NULL},
	 { "acc_code_parity_max", _wrap_acc_code_parity_max, METH_VARARGS, NULL},
	 { "acc_code_parity_max_odd", _wrap_acc_code_parity_max_odd, METH_O, NULL},
	 { "acc_code_parity_max_even", _wrap_acc_code_parity_max_even, METH_O, NULL},
	 { "acc_code_parity_min", _wrap_acc_code_parity_min, METH_VARARGS, NULL},
	 { "acc_code_parity_min_odd", _wrap_acc_code_parity_min_odd, METH_O, NULL},
	 { "acc_code_parity_min_even", _wrap_acc_code_parity_min_even, METH_O, NULL},
	 { "acc_code_random", _wrap_acc_code_random, METH_VARARGS, NULL},
	 { "acc_code___iand__", _wrap_acc_code___iand__, METH_VARARGS, NULL},
	 { "acc_code___and__", _wrap_acc_code___and__, METH_VARARGS, NULL},
	 { "acc_code___ior__", _wrap_acc_code___ior__, METH_VARARGS, NULL},
	 { "acc_code___or__", _wrap_acc_code___or__, METH_VARARGS, NULL},
	 { "acc_code___ilshift__", _wrap_acc_code___ilshift__, METH_VARARGS, NULL},
	 { "acc_code___lshift__", _wrap_acc_code___lshift__, METH_VARARGS, NULL},
	 { "acc_code_is_dnf", _wrap_acc_code_is_dnf, METH_O, NULL},
	 { "acc_code_is_cnf", _wrap_acc_code_is_cnf, METH_O, NULL},
	 { "acc_code_to_dnf", _wrap_acc_code_to_dnf, METH_O, NULL},
	 { "acc_code_to_cnf", _wrap_acc_code_to_cnf, METH_O, NULL},
	 { "acc_code_to_bdd", _wrap_acc_code_to_bdd, METH_VARARGS, NULL},
	 { "acc_code_top_disjuncts", _wrap_acc_code_top_disjuncts, METH_O, NULL},
	 { "acc_code_top_conjuncts", _wrap_acc_code_top_conjuncts, METH_O, NULL},
	 { "acc_code_complement", _wrap_acc_code_complement, METH_O, NULL},
	 { "acc_code_fin_unit", _wrap_acc_code_fin_unit, METH_O, NULL},
	 { "acc_code_inf_unit", _wrap_acc_code_inf_unit, METH_O, NULL},
	 { "acc_code_fin_one", _wrap_acc_code_fin_one, METH_O, NULL},
	 { "acc_code_fin_one_extract", _wrap_acc_code_fin_one_extract, METH_O, NULL},
	 { "acc_code_fin_unit_one_split", _wrap_acc_code_fin_unit_one_split, METH_O, NULL},
	 { "acc_code_missing", _wrap_acc_code_missing, METH_VARARGS, NULL},
	 { "acc_code_accepting", _wrap_acc_code_accepting, METH_VARARGS, NULL},
	 { "acc_code_inf_satisfiable", _wrap_acc_code_inf_satisfiable, METH_VARARGS, NULL},
	 { "acc_code_maybe_accepting", _wrap_acc_code_maybe_accepting, METH_VARARGS, NULL},
	 { "acc_code_symmetries", _wrap_acc_code_symmetries, METH_O, NULL},
	 { "acc_code_remove", _wrap_acc_code_remove, METH_VARARGS, NULL},
	 { "acc_code_strip", _wrap_acc_code_strip, METH_VARARGS, NULL},
	 { "acc_code_force_inf", _wrap_acc_code_force_inf, METH_VARARGS, NULL},
	 { "acc_code_used_sets", _wrap_acc_code_used_sets, METH_O, NULL},
	 { "acc_code_useless_colors_patterns", _wrap_acc_code_useless_colors_patterns, METH_O, NULL},
	 { "acc_code_used_once_sets", _wrap_acc_code_used_once_sets, METH_O, NULL},
	 { "acc_code_used_inf_fin_sets", _wrap_acc_code_used_inf_fin_sets, METH_O, NULL},
	 { "acc_code_to_html", _wrap_acc_code_to_html, METH_VARARGS, NULL},
	 { "acc_code_to_text", _wrap_acc_code_to_text, METH_VARARGS, NULL},
	 { "acc_code_to_latex", _wrap_acc_code_to_latex, METH_VARARGS, NULL},
	 { "new_acc_code", _wrap_new_acc_code, METH_VARARGS, NULL},
	 { "acc_code___repr__", _wrap_acc_code___repr__, METH_O, NULL},
	 { "acc_code___str__", _wrap_acc_code___str__, METH_O, NULL},
	 { "delete_acc_code", _wrap_delete_acc_code, METH_O, NULL},
	 { "acc_code_swigregister", acc_code_swigregister, METH_O, NULL},
	 { "acc_code_swiginit", acc_code_swiginit, METH_VARARGS, NULL},
	 { "new_rs_pair", _wrap_new_rs_pair, METH_VARARGS, NULL},
	 { "rs_pair_fin_set", _wrap_rs_pair_fin_set, METH_VARARGS, NULL},
	 { "rs_pair_fin_get", _wrap_rs_pair_fin_get, METH_O, NULL},
	 { "rs_pair_inf_set", _wrap_rs_pair_inf_set, METH_VARARGS, NULL},
	 { "rs_pair_inf_get", _wrap_rs_pair_inf_get, METH_O, NULL},
	 { "rs_pair___eq__", _wrap_rs_pair___eq__, METH_VARARGS, NULL},
	 { "rs_pair___ne__", _wrap_rs_pair___ne__, METH_VARARGS, NULL},
	 { "rs_pair___lt__", _wrap_rs_pair___lt__, METH_VARARGS, NULL},
	 { "rs_pair___le__", _wrap_rs_pair___le__, METH_VARARGS, NULL},
	 { "rs_pair___gt__", _wrap_rs_pair___gt__, METH_VARARGS, NULL},
	 { "rs_pair___ge__", _wrap_rs_pair___ge__, METH_VARARGS, NULL},
	 { "rs_pair___repr__", _wrap_rs_pair___repr__, METH_O, NULL},
	 { "delete_rs_pair", _wrap_delete_rs_pair, METH_O, NULL},
	 { "rs_pair_swigregister", rs_pair_swigregister, METH_O, NULL},
	 { "rs_pair_swiginit", rs_pair_swiginit, METH_VARARGS, NULL},
	 { "new_rs_pairs_view", _wrap_new_rs_pairs_view, METH_VARARGS, NULL},
	 { "rs_pairs_view_infs", _wrap_rs_pairs_view_infs, METH_O, NULL},
	 { "rs_pairs_view_fins", _wrap_rs_pairs_view_fins, METH_O, NULL},
	 { "rs_pairs_view_fins_alone", _wrap_rs_pairs_view_fins_alone, METH_O, NULL},
	 { "rs_pairs_view_infs_alone", _wrap_rs_pairs_view_infs_alone, METH_O, NULL},
	 { "rs_pairs_view_paired_with_fin", _wrap_rs_pairs_view_paired_with_fin, METH_VARARGS, NULL},
	 { "rs_pairs_view_pairs", _wrap_rs_pairs_view_pairs, METH_O, NULL},
	 { "delete_rs_pairs_view", _wrap_delete_rs_pairs_view, METH_O, NULL},
	 { "rs_pairs_view_swigregister", rs_pairs_view_swigregister, METH_O, NULL},
	 { "rs_pairs_view_swiginit", rs_pairs_view_swiginit, METH_VARARGS, NULL},
	 { "new_mark_iterator", _wrap_new_mark_iterator, METH_VARARGS, NULL},
	 { "mark_iterator___eq__", _wrap_mark_iterator___eq__, METH_VARARGS, NULL},
	 { "mark_iterator___ne__", _wrap_mark_iterator___ne__, METH_VARARGS, NULL},
	 { "mark_iterator___ref__", _wrap_mark_iterator___ref__, METH_O, NULL},
	 { "delete_mark_iterator", _wrap_delete_mark_iterator, METH_O, NULL},
	 { "mark_iterator_swigregister", mark_iterator_swigregister, METH_O, NULL},
	 { "mark_iterator_swiginit", mark_iterator_swiginit, METH_VARARGS, NULL},
	 { "new_mark_container", _wrap_new_mark_container, METH_O, NULL},
	 { "mark_container_begin", _wrap_mark_container_begin, METH_O, NULL},
	 { "mark_container_end", _wrap_mark_container_end, METH_O, NULL},
	 { "mark_container___iter__", _wrap_mark_container___iter__, METH_O, NULL},
	 { "delete_mark_container", _wrap_delete_mark_container, METH_O, NULL},
	 { "mark_container_swigregister", mark_container_swigregister, METH_O, NULL},
	 { "mark_container_swiginit", mark_container_swiginit, METH_VARARGS, NULL},
	 { "new_pair_bool_mark", _wrap_new_pair_bool_mark, METH_VARARGS, NULL},
	 { "pair_bool_mark_first_set", _wrap_pair_bool_mark_first_set, METH_VARARGS, NULL},
	 { "pair_bool_mark_first_get", _wrap_pair_bool_mark_first_get, METH_O, NULL},
	 { "pair_bool_mark_second_set", _wrap_pair_bool_mark_second_set, METH_VARARGS, NULL},
	 { "pair_bool_mark_second_get", _wrap_pair_bool_mark_second_get, METH_O, NULL},
	 { "delete_pair_bool_mark", _wrap_delete_pair_bool_mark, METH_O, NULL},
	 { "pair_bool_mark_swigregister", pair_bool_mark_swigregister, METH_O, NULL},
	 { "pair_bool_mark_swiginit", pair_bool_mark_swiginit, METH_VARARGS, NULL},
	 { "state_compare", _wrap_state_compare, METH_VARARGS, NULL},
	 { "state_hash", _wrap_state_hash, METH_O, NULL},
	 { "state_clone", _wrap_state_clone, METH_O, NULL},
	 { "state_destroy", _wrap_state_destroy, METH_O, NULL},
	 { "state_swigregister", state_swigregister, METH_O, NULL},
	 { "state_ptr_less_than___call__", _wrap_state_ptr_less_than___call__, METH_VARARGS, NULL},
	 { "new_state_ptr_less_than", _wrap_new_state_ptr_less_than, METH_NOARGS, NULL},
	 { "delete_state_ptr_less_than", _wrap_delete_state_ptr_less_than, METH_O, NULL},
	 { "state_ptr_less_than_swigregister", state_ptr_less_than_swigregister, METH_O, NULL},
	 { "state_ptr_less_than_swiginit", state_ptr_less_than_swiginit, METH_VARARGS, NULL},
	 { "state_ptr_equal___call__", _wrap_state_ptr_equal___call__, METH_VARARGS, NULL},
	 { "new_state_ptr_equal", _wrap_new_state_ptr_equal, METH_NOARGS, NULL},
	 { "delete_state_ptr_equal", _wrap_delete_state_ptr_equal, METH_O, NULL},
	 { "state_ptr_equal_swigregister", state_ptr_equal_swigregister, METH_O, NULL},
	 { "state_ptr_equal_swiginit", state_ptr_equal_swiginit, METH_VARARGS, NULL},
	 { "state_ptr_hash___call__", _wrap_state_ptr_hash___call__, METH_VARARGS, NULL},
	 { "new_state_ptr_hash", _wrap_new_state_ptr_hash, METH_NOARGS, NULL},
	 { "delete_state_ptr_hash", _wrap_delete_state_ptr_hash, METH_O, NULL},
	 { "state_ptr_hash_swigregister", state_ptr_hash_swigregister, METH_O, NULL},
	 { "state_ptr_hash_swiginit", state_ptr_hash_swiginit, METH_VARARGS, NULL},
	 { "state_unicity_table___call__", _wrap_state_unicity_table___call__, METH_VARARGS, NULL},
	 { "state_unicity_table_is_new", _wrap_state_unicity_table_is_new, METH_VARARGS, NULL},
	 { "delete_state_unicity_table", _wrap_delete_state_unicity_table, METH_O, NULL},
	 { "state_unicity_table_size", _wrap_state_unicity_table_size, METH_O, NULL},
	 { "new_state_unicity_table", _wrap_new_state_unicity_table, METH_NOARGS, NULL},
	 { "state_unicity_table_swigregister", state_unicity_table_swigregister, METH_O, NULL},
	 { "state_unicity_table_swiginit", state_unicity_table_swiginit, METH_VARARGS, NULL},
	 { "shared_state_deleter", _wrap_shared_state_deleter, METH_O, NULL},
	 { "state_shared_ptr_less_than___call__", _wrap_state_shared_ptr_less_than___call__, METH_VARARGS, NULL},
	 { "new_state_shared_ptr_less_than", _wrap_new_state_shared_ptr_less_than, METH_NOARGS, NULL},
	 { "delete_state_shared_ptr_less_than", _wrap_delete_state_shared_ptr_less_than, METH_O, NULL},
	 { "state_shared_ptr_less_than_swigregister", state_shared_ptr_less_than_swigregister, METH_O, NULL},
	 { "state_shared_ptr_less_than_swiginit", state_shared_ptr_less_than_swiginit, METH_VARARGS, NULL},
	 { "state_shared_ptr_equal___call__", _wrap_state_shared_ptr_equal___call__, METH_VARARGS, NULL},
	 { "new_state_shared_ptr_equal", _wrap_new_state_shared_ptr_equal, METH_NOARGS, NULL},
	 { "delete_state_shared_ptr_equal", _wrap_delete_state_shared_ptr_equal, METH_O, NULL},
	 { "state_shared_ptr_equal_swigregister", state_shared_ptr_equal_swigregister, METH_O, NULL},
	 { "state_shared_ptr_equal_swiginit", state_shared_ptr_equal_swiginit, METH_VARARGS, NULL},
	 { "state_shared_ptr_hash___call__", _wrap_state_shared_ptr_hash___call__, METH_VARARGS, NULL},
	 { "new_state_shared_ptr_hash", _wrap_new_state_shared_ptr_hash, METH_NOARGS, NULL},
	 { "delete_state_shared_ptr_hash", _wrap_delete_state_shared_ptr_hash, METH_O, NULL},
	 { "state_shared_ptr_hash_swigregister", state_shared_ptr_hash_swigregister, METH_O, NULL},
	 { "state_shared_ptr_hash_swiginit", state_shared_ptr_hash_swiginit, METH_VARARGS, NULL},
	 { "delete_twa_succ_iterator", _wrap_delete_twa_succ_iterator, METH_O, NULL},
	 { "twa_succ_iterator_first", _wrap_twa_succ_iterator_first, METH_O, NULL},
	 { "twa_succ_iterator_next", _wrap_twa_succ_iterator_next, METH_O, NULL},
	 { "twa_succ_iterator_done", _wrap_twa_succ_iterator_done, METH_O, NULL},
	 { "twa_succ_iterator_dst", _wrap_twa_succ_iterator_dst, METH_O, NULL},
	 { "twa_succ_iterator_cond", _wrap_twa_succ_iterator_cond, METH_O, NULL},
	 { "twa_succ_iterator_acc", _wrap_twa_succ_iterator_acc, METH_O, NULL},
	 { "twa_succ_iterator_swigregister", twa_succ_iterator_swigregister, METH_O, NULL},
	 { "new_succ_iterator", _wrap_new_succ_iterator, METH_O, NULL},
	 { "succ_iterator___eq__", _wrap_succ_iterator___eq__, METH_VARARGS, NULL},
	 { "succ_iterator___ne__", _wrap_succ_iterator___ne__, METH_VARARGS, NULL},
	 { "succ_iterator___ref__", _wrap_succ_iterator___ref__, METH_O, NULL},
	 { "delete_succ_iterator", _wrap_delete_succ_iterator, METH_O, NULL},
	 { "succ_iterator_swigregister", succ_iterator_swigregister, METH_O, NULL},
	 { "succ_iterator_swiginit", succ_iterator_swiginit, METH_VARARGS, NULL},
	 { "delete_twa", _wrap_delete_twa, METH_O, NULL},
	 { "twa_get_init_state", _wrap_twa_get_init_state, METH_O, NULL},
	 { "twa_succ_iter", _wrap_twa_succ_iter, METH_VARARGS, NULL},
	 { "twa_release_iter", _wrap_twa_release_iter, METH_VARARGS, NULL},
	 { "twa_get_dict", _wrap_twa_get_dict, METH_O, NULL},
	 { "twa_register_ap", _wrap_twa_register_ap, METH_VARARGS, NULL},
	 { "twa_unregister_ap", _wrap_twa_unregister_ap, METH_VARARGS, NULL},
	 { "twa_register_aps_from_dict", _wrap_twa_register_aps_from_dict, METH_O, NULL},
	 { "twa_ap", _wrap_twa_ap, METH_O, NULL},
	 { "twa_ap_vars", _wrap_twa_ap_vars, METH_O, NULL},
	 { "twa_format_state", _wrap_twa_format_state, METH_VARARGS, NULL},
	 { "twa_project_state", _wrap_twa_project_state, METH_VARARGS, NULL},
	 { "twa_acc", _wrap_twa_acc, METH_VARARGS, NULL},
	 { "twa_is_empty", _wrap_twa_is_empty, METH_O, NULL},
	 { "twa_accepting_run", _wrap_twa_accepting_run, METH_O, NULL},
	 { "twa_accepting_word", _wrap_twa_accepting_word, METH_O, NULL},
	 { "twa_intersects", _wrap_twa_intersects, METH_VARARGS, NULL},
	 { "twa_intersecting_run", _wrap_twa_intersecting_run, METH_VARARGS, NULL},
	 { "twa_intersecting_word", _wrap_twa_intersecting_word, METH_VARARGS, NULL},
	 { "twa_exclusive_run", _wrap_twa_exclusive_run, METH_VARARGS, NULL},
	 { "twa_exclusive_word", _wrap_twa_exclusive_word, METH_VARARGS, NULL},
	 { "twa_num_sets", _wrap_twa_num_sets, METH_O, NULL},
	 { "twa_get_acceptance", _wrap_twa_get_acceptance, METH_O, NULL},
	 { "twa_set_acceptance", _wrap_twa_set_acceptance, METH_VARARGS, NULL},
	 { "twa_copy_acceptance_of", _wrap_twa_copy_acceptance_of, METH_VARARGS, NULL},
	 { "twa_copy_ap_of", _wrap_twa_copy_ap_of, METH_VARARGS, NULL},
	 { "twa_copy_named_properties_of", _wrap_twa_copy_named_properties_of, METH_VARARGS, NULL},
	 { "twa_set_generalized_buchi", _wrap_twa_set_generalized_buchi, METH_VARARGS, NULL},
	 { "twa_set_generalized_co_buchi", _wrap_twa_set_generalized_co_buchi, METH_VARARGS, NULL},
	 { "twa_set_buchi", _wrap_twa_set_buchi, METH_O, NULL},
	 { "twa_set_co_buchi", _wrap_twa_set_co_buchi, METH_O, NULL},
	 { "twa_release_named_properties", _wrap_twa_release_named_properties, METH_O, NULL},
	 { "twa_prop_state_acc", _wrap_twa_prop_state_acc, METH_VARARGS, NULL},
	 { "twa_is_sba", _wrap_twa_is_sba, METH_O, NULL},
	 { "twa_prop_inherently_weak", _wrap_twa_prop_inherently_weak, METH_VARARGS, NULL},
	 { "twa_prop_terminal", _wrap_twa_prop_terminal, METH_VARARGS, NULL},
	 { "twa_prop_weak", _wrap_twa_prop_weak, METH_VARARGS, NULL},
	 { "twa_prop_very_weak", _wrap_twa_prop_very_weak, METH_VARARGS, NULL},
	 { "twa_prop_complete", _wrap_twa_prop_complete, METH_VARARGS, NULL},
	 { "twa_prop_universal", _wrap_twa_prop_universal, METH_VARARGS, NULL},
	 { "twa_prop_deterministic", _wrap_twa_prop_deterministic, METH_VARARGS, NULL},
	 { "twa_prop_unambiguous", _wrap_twa_prop_unambiguous, METH_VARARGS, NULL},
	 { "twa_prop_semi_deterministic", _wrap_twa_prop_semi_deterministic, METH_VARARGS, NULL},
	 { "twa_prop_stutter_invariant", _wrap_twa_prop_stutter_invariant, METH_VARARGS, NULL},
	 { "twa_prop_copy", _wrap_twa_prop_copy, METH_VARARGS, NULL},
	 { "twa_prop_keep", _wrap_twa_prop_keep, METH_VARARGS, NULL},
	 { "twa_prop_reset", _wrap_twa_prop_reset, METH_O, NULL},
	 { "twa_set_name", _wrap_twa_set_name, METH_VARARGS, NULL},
	 { "twa_get_name", _wrap_twa_get_name, METH_O, NULL},
	 { "twa_set_state_names", _wrap_twa_set_state_names, METH_VARARGS, NULL},
	 { "twa_get_state_names", _wrap_twa_get_state_names, METH_O, NULL},
	 { "twa_set_product_states", _wrap_twa_set_product_states, METH_VARARGS, NULL},
	 { "twa_get_product_states", _wrap_twa_get_product_states, METH_O, NULL},
	 { "twa_get_original_states", _wrap_twa_get_original_states, METH_O, NULL},
	 { "twa_get_original_classes", _wrap_twa_get_original_classes, METH_O, NULL},
	 { "twa_highlight_state", _wrap_twa_highlight_state, METH_VARARGS, NULL},
	 { "twa_highlight_edge", _wrap_twa_highlight_edge, METH_VARARGS, NULL},
	 { "twa_swigregister", twa_swigregister, METH_O, NULL},
	 { "twa_prop_set_state_based_set", _wrap_twa_prop_set_state_based_set, METH_VARARGS, NULL},
	 { "twa_prop_set_state_based_get", _wrap_twa_prop_set_state_based_get, METH_O, NULL},
	 { "twa_prop_set_inherently_weak_set", _wrap_twa_prop_set_inherently_weak_set, METH_VARARGS, NULL},
	 { "twa_prop_set_inherently_weak_get", _wrap_twa_prop_set_inherently_weak_get, METH_O, NULL},
	 { "twa_prop_set_deterministic_set", _wrap_twa_prop_set_deterministic_set, METH_VARARGS, NULL},
	 { "twa_prop_set_deterministic_get", _wrap_twa_prop_set_deterministic_get, METH_O, NULL},
	 { "twa_prop_set_improve_det_set", _wrap_twa_prop_set_improve_det_set, METH_VARARGS, NULL},
	 { "twa_prop_set_improve_det_get", _wrap_twa_prop_set_improve_det_get, METH_O, NULL},
	 { "twa_prop_set_complete_set", _wrap_twa_prop_set_complete_set, METH_VARARGS, NULL},
	 { "twa_prop_set_complete_get", _wrap_twa_prop_set_complete_get, METH_O, NULL},
	 { "twa_prop_set_stutter_inv_set", _wrap_twa_prop_set_stutter_inv_set, METH_VARARGS, NULL},
	 { "twa_prop_set_stutter_inv_get", _wrap_twa_prop_set_stutter_inv_get, METH_O, NULL},
	 { "new_twa_prop_set", _wrap_new_twa_prop_set, METH_VARARGS, NULL},
	 { "twa_prop_set_all", _wrap_twa_prop_set_all, METH_NOARGS, NULL},
	 { "delete_twa_prop_set", _wrap_delete_twa_prop_set, METH_O, NULL},
	 { "twa_prop_set_swigregister", twa_prop_set_swigregister, METH_O, NULL},
	 { "twa_prop_set_swiginit", twa_prop_set_swiginit, METH_VARARGS, NULL},
	 { "create_atomic_prop_set", _wrap_create_atomic_prop_set, METH_O, NULL},
	 { "atomic_prop_collect", _wrap_atomic_prop_collect, METH_VARARGS, NULL},
	 { "atomic_prop_collect_as_bdd", _wrap_atomic_prop_collect_as_bdd, METH_VARARGS, NULL},
	 { "new_language_containment_checker", _wrap_new_language_containment_checker, METH_VARARGS, NULL},
	 { "delete_language_containment_checker", _wrap_delete_language_containment_checker, METH_O, NULL},
	 { "language_containment_checker_clear", _wrap_language_containment_checker_clear, METH_O, NULL},
	 { "language_containment_checker_contained", _wrap_language_containment_checker_contained, METH_VARARGS, NULL},
	 { "language_containment_checker_neg_contained", _wrap_language_containment_checker_neg_contained, METH_VARARGS, NULL},
	 { "language_containment_checker_contained_neg", _wrap_language_containment_checker_contained_neg, METH_VARARGS, NULL},
	 { "language_containment_checker_equal", _wrap_language_containment_checker_equal, METH_VARARGS, NULL},
	 { "language_containment_checker_swigregister", language_containment_checker_swigregister, METH_O, NULL},
	 { "language_containment_checker_swiginit", language_containment_checker_swiginit, METH_VARARGS, NULL},
	 { "print_dot_psl", _wrap_print_dot_psl, METH_VARARGS, NULL},
	 { "negative_normal_form", _wrap_negative_normal_form, METH_VARARGS, NULL},
	 { "suffix_operator_normal_form", _wrap_suffix_operator_normal_form, METH_VARARGS, NULL},
	 { "print_psl", _wrap_print_psl, METH_VARARGS, NULL},
	 { "str_psl", _wrap_str_psl, METH_VARARGS, NULL},
	 { "print_utf8_psl", _wrap_print_utf8_psl, METH_VARARGS, NULL},
	 { "str_utf8_psl", _wrap_str_utf8_psl, METH_VARARGS, NULL},
	 { "print_sere", _wrap_print_sere, METH_VARARGS, NULL},
	 { "str_sere", _wrap_str_sere, METH_VARARGS, NULL},
	 { "print_utf8_sere", _wrap_print_utf8_sere, METH_VARARGS, NULL},
	 { "str_utf8_sere", _wrap_str_utf8_sere, METH_VARARGS, NULL},
	 { "print_spin_ltl", _wrap_print_spin_ltl, METH_VARARGS, NULL},
	 { "str_spin_ltl", _wrap_str_spin_ltl, METH_VARARGS, NULL},
	 { "print_wring_ltl", _wrap_print_wring_ltl, METH_VARARGS, NULL},
	 { "str_wring_ltl", _wrap_str_wring_ltl, METH_O, NULL},
	 { "print_latex_psl", _wrap_print_latex_psl, METH_VARARGS, NULL},
	 { "str_latex_psl", _wrap_str_latex_psl, METH_VARARGS, NULL},
	 { "print_latex_sere", _wrap_print_latex_sere, METH_VARARGS, NULL},
	 { "str_latex_sere", _wrap_str_latex_sere, METH_VARARGS, NULL},
	 { "print_sclatex_psl", _wrap_print_sclatex_psl, METH_VARARGS, NULL},
	 { "str_sclatex_psl", _wrap_str_sclatex_psl, METH_VARARGS, NULL},
	 { "print_sclatex_sere", _wrap_print_sclatex_sere, METH_VARARGS, NULL},
	 { "str_sclatex_sere", _wrap_str_sclatex_sere, METH_VARARGS, NULL},
	 { "print_lbt_ltl", _wrap_print_lbt_ltl, METH_VARARGS, NULL},
	 { "str_lbt_ltl", _wrap_str_lbt_ltl, METH_O, NULL},
	 { "new_tl_simplifier_options", _wrap_new_tl_simplifier_options, METH_VARARGS, NULL},
	 { "tl_simplifier_options_reduce_basics_set", _wrap_tl_simplifier_options_reduce_basics_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_reduce_basics_get", _wrap_tl_simplifier_options_reduce_basics_get, METH_O, NULL},
	 { "tl_simplifier_options_synt_impl_set", _wrap_tl_simplifier_options_synt_impl_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_synt_impl_get", _wrap_tl_simplifier_options_synt_impl_get, METH_O, NULL},
	 { "tl_simplifier_options_event_univ_set", _wrap_tl_simplifier_options_event_univ_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_event_univ_get", _wrap_tl_simplifier_options_event_univ_get, METH_O, NULL},
	 { "tl_simplifier_options_containment_checks_set", _wrap_tl_simplifier_options_containment_checks_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_containment_checks_get", _wrap_tl_simplifier_options_containment_checks_get, METH_O, NULL},
	 { "tl_simplifier_options_containment_checks_stronger_set", _wrap_tl_simplifier_options_containment_checks_stronger_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_containment_checks_stronger_get", _wrap_tl_simplifier_options_containment_checks_stronger_get, METH_O, NULL},
	 { "tl_simplifier_options_nenoform_stop_on_boolean_set", _wrap_tl_simplifier_options_nenoform_stop_on_boolean_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_nenoform_stop_on_boolean_get", _wrap_tl_simplifier_options_nenoform_stop_on_boolean_get, METH_O, NULL},
	 { "tl_simplifier_options_reduce_size_strictly_set", _wrap_tl_simplifier_options_reduce_size_strictly_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_reduce_size_strictly_get", _wrap_tl_simplifier_options_reduce_size_strictly_get, METH_O, NULL},
	 { "tl_simplifier_options_boolean_to_isop_set", _wrap_tl_simplifier_options_boolean_to_isop_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_boolean_to_isop_get", _wrap_tl_simplifier_options_boolean_to_isop_get, METH_O, NULL},
	 { "tl_simplifier_options_favor_event_univ_set", _wrap_tl_simplifier_options_favor_event_univ_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_favor_event_univ_get", _wrap_tl_simplifier_options_favor_event_univ_get, METH_O, NULL},
	 { "tl_simplifier_options_keep_top_xor_set", _wrap_tl_simplifier_options_keep_top_xor_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_keep_top_xor_get", _wrap_tl_simplifier_options_keep_top_xor_get, METH_O, NULL},
	 { "tl_simplifier_options_containment_max_states_set", _wrap_tl_simplifier_options_containment_max_states_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_containment_max_states_get", _wrap_tl_simplifier_options_containment_max_states_get, METH_O, NULL},
	 { "tl_simplifier_options_containment_max_ops_set", _wrap_tl_simplifier_options_containment_max_ops_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_containment_max_ops_get", _wrap_tl_simplifier_options_containment_max_ops_get, METH_O, NULL},
	 { "delete_tl_simplifier_options", _wrap_delete_tl_simplifier_options, METH_O, NULL},
	 { "tl_simplifier_options_swigregister", tl_simplifier_options_swigregister, METH_O, NULL},
	 { "tl_simplifier_options_swiginit", tl_simplifier_options_swiginit, METH_VARARGS, NULL},
	 { "new_tl_simplifier", _wrap_new_tl_simplifier, METH_VARARGS, NULL},
	 { "delete_tl_simplifier", _wrap_delete_tl_simplifier, METH_O, NULL},
	 { "tl_simplifier_simplify", _wrap_tl_simplifier_simplify, METH_VARARGS, NULL},
	 { "tl_simplifier_negative_normal_form", _wrap_tl_simplifier_negative_normal_form, METH_VARARGS, NULL},
	 { "tl_simplifier_syntactic_implication", _wrap_tl_simplifier_syntactic_implication, METH_VARARGS, NULL},
	 { "tl_simplifier_syntactic_implication_neg", _wrap_tl_simplifier_syntactic_implication_neg, METH_VARARGS, NULL},
	 { "tl_simplifier_are_equivalent", _wrap_tl_simplifier_are_equivalent, METH_VARARGS, NULL},
	 { "tl_simplifier_implication", _wrap_tl_simplifier_implication, METH_VARARGS, NULL},
	 { "tl_simplifier_as_bdd", _wrap_tl_simplifier_as_bdd, METH_VARARGS, NULL},
	 { "tl_simplifier_clear_as_bdd_cache", _wrap_tl_simplifier_clear_as_bdd_cache, METH_O, NULL},
	 { "tl_simplifier_clear_caches", _wrap_tl_simplifier_clear_caches, METH_O, NULL},
	 { "tl_simplifier_get_dict", _wrap_tl_simplifier_get_dict, METH_O, NULL},
	 { "tl_simplifier_star_normal_form", _wrap_tl_simplifier_star_normal_form, METH_VARARGS, NULL},
	 { "tl_simplifier_boolean_to_isop", _wrap_tl_simplifier_boolean_to_isop, METH_VARARGS, NULL},
	 { "tl_simplifier_print_stats", _wrap_tl_simplifier_print_stats, METH_VARARGS, NULL},
	 { "tl_simplifier_swigregister", tl_simplifier_swigregister, METH_O, NULL},
	 { "tl_simplifier_swiginit", tl_simplifier_swiginit, METH_VARARGS, NULL},
	 { "new_unabbreviator", _wrap_new_unabbreviator, METH_VARARGS, NULL},
	 { "unabbreviator_run", _wrap_unabbreviator_run, METH_VARARGS, NULL},
	 { "delete_unabbreviator", _wrap_delete_unabbreviator, METH_O, NULL},
	 { "unabbreviator_swigregister", unabbreviator_swigregister, METH_O, NULL},
	 { "unabbreviator_swiginit", unabbreviator_swiginit, METH_VARARGS, NULL},
	 { "unabbreviate", _wrap_unabbreviate, METH_VARARGS, NULL},
	 { "new_random_formula", _wrap_new_random_formula, METH_VARARGS, NULL},
	 { "delete_random_formula", _wrap_delete_random_formula, METH_O, NULL},
	 { "random_formula_ap", _wrap_random_formula_ap, METH_O, NULL},
	 { "random_formula_generate", _wrap_random_formula_generate, METH_VARARGS, NULL},
	 { "random_formula_dump_priorities", _wrap_random_formula_dump_priorities, METH_VARARGS, NULL},
	 { "random_formula_parse_options", _wrap_random_formula_parse_options, METH_VARARGS, NULL},
	 { "random_formula_swigregister", random_formula_swigregister, METH_O, NULL},
	 { "random_formula_swiginit", random_formula_swiginit, METH_VARARGS, NULL},
	 { "new_random_ltl", _wrap_new_random_ltl, METH_O, NULL},
	 { "delete_random_ltl", _wrap_delete_random_ltl, METH_O, NULL},
	 { "random_ltl_swigregister", random_ltl_swigregister, METH_O, NULL},
	 { "random_ltl_swiginit", random_ltl_swiginit, METH_VARARGS, NULL},
	 { "new_random_boolean", _wrap_new_random_boolean, METH_O, NULL},
	 { "delete_random_boolean", _wrap_delete_random_boolean, METH_O, NULL},
	 { "random_boolean_swigregister", random_boolean_swigregister, METH_O, NULL},
	 { "random_boolean_swiginit", random_boolean_swiginit, METH_VARARGS, NULL},
	 { "new_random_sere", _wrap_new_random_sere, METH_O, NULL},
	 { "random_sere_rb_set", _wrap_random_sere_rb_set, METH_VARARGS, NULL},
	 { "random_sere_rb_get", _wrap_random_sere_rb_get, METH_O, NULL},
	 { "delete_random_sere", _wrap_delete_random_sere, METH_O, NULL},
	 { "random_sere_swigregister", random_sere_swigregister, METH_O, NULL},
	 { "random_sere_swiginit", random_sere_swiginit, METH_VARARGS, NULL},
	 { "new_random_psl", _wrap_new_random_psl, METH_O, NULL},
	 { "random_psl_rs_set", _wrap_random_psl_rs_set, METH_VARARGS, NULL},
	 { "random_psl_rs_get", _wrap_random_psl_rs_get, METH_O, NULL},
	 { "delete_random_psl", _wrap_delete_random_psl, METH_O, NULL},
	 { "random_psl_swigregister", random_psl_swigregister, METH_O, NULL},
	 { "random_psl_swiginit", random_psl_swiginit, METH_VARARGS, NULL},
	 { "new_randltlgenerator", _wrap_new_randltlgenerator, METH_VARARGS, NULL},
	 { "delete_randltlgenerator", _wrap_delete_randltlgenerator, METH_O, NULL},
	 { "randltlgenerator_next", _wrap_randltlgenerator_next, METH_O, NULL},
	 { "randltlgenerator_dump_ltl_priorities", _wrap_randltlgenerator_dump_ltl_priorities, METH_VARARGS, NULL},
	 { "randltlgenerator_dump_bool_priorities", _wrap_randltlgenerator_dump_bool_priorities, METH_VARARGS, NULL},
	 { "randltlgenerator_dump_psl_priorities", _wrap_randltlgenerator_dump_psl_priorities, METH_VARARGS, NULL},
	 { "randltlgenerator_dump_sere_priorities", _wrap_randltlgenerator_dump_sere_priorities, METH_VARARGS, NULL},
	 { "randltlgenerator_dump_sere_bool_priorities", _wrap_randltlgenerator_dump_sere_bool_priorities, METH_VARARGS, NULL},
	 { "randltlgenerator_remove_some_props", _wrap_randltlgenerator_remove_some_props, METH_VARARGS, NULL},
	 { "randltlgenerator_GF_n", _wrap_randltlgenerator_GF_n, METH_O, NULL},
	 { "randltlgenerator_swigregister", randltlgenerator_swigregister, METH_O, NULL},
	 { "randltlgenerator_swiginit", randltlgenerator_swiginit, METH_VARARGS, NULL},
	 { "length", _wrap_length, METH_O, NULL},
	 { "length_boolone", _wrap_length_boolone, METH_O, NULL},
	 { "from_ltlf", _wrap_from_ltlf, METH_VARARGS, NULL},
	 { "is_persistence", _wrap_is_persistence, METH_VARARGS, NULL},
	 { "is_recurrence", _wrap_is_recurrence, METH_VARARGS, NULL},
	 { "is_obligation", _wrap_is_obligation, METH_VARARGS, NULL},
	 { "mp_class", _wrap_mp_class, METH_VARARGS, NULL},
	 { "nesting_depth", _wrap_nesting_depth, METH_VARARGS, NULL},
	 { "is_liveness", _wrap_is_liveness, METH_O, NULL},
	 { "remove_x", _wrap_remove_x, METH_O, NULL},
	 { "relabel", _wrap_relabel, METH_VARARGS, NULL},
	 { "relabel_bse", _wrap_relabel_bse, METH_VARARGS, NULL},
	 { "relabel_apply", _wrap_relabel_apply, METH_VARARGS, NULL},
	 { "taa_tgba_add_condition", _wrap_taa_tgba_add_condition, METH_VARARGS, NULL},
	 { "delete_taa_tgba", _wrap_delete_taa_tgba, METH_O, NULL},
	 { "taa_tgba_get_init_state", _wrap_taa_tgba_get_init_state, METH_O, NULL},
	 { "taa_tgba_swigregister", taa_tgba_swigregister, METH_O, NULL},
	 { "new_set_state", _wrap_new_set_state, METH_VARARGS, NULL},
	 { "set_state_clone", _wrap_set_state_clone, METH_O, NULL},
	 { "delete_set_state", _wrap_delete_set_state, METH_O, NULL},
	 { "set_state_get_state", _wrap_set_state_get_state, METH_O, NULL},
	 { "set_state_swigregister", set_state_swigregister, METH_O, NULL},
	 { "set_state_swiginit", set_state_swiginit, METH_VARARGS, NULL},
	 { "new_taa_succ_iterator", _wrap_new_taa_succ_iterator, METH_VARARGS, NULL},
	 { "delete_taa_succ_iterator", _wrap_delete_taa_succ_iterator, METH_O, NULL},
	 { "taa_succ_iterator_dst", _wrap_taa_succ_iterator_dst, METH_O, NULL},
	 { "taa_succ_iterator_swigregister", taa_succ_iterator_swigregister, METH_O, NULL},
	 { "taa_succ_iterator_swiginit", taa_succ_iterator_swiginit, METH_VARARGS, NULL},
	 { "delete_taa_tgba_string", _wrap_delete_taa_tgba_string, METH_O, NULL},
	 { "taa_tgba_string_swigregister", taa_tgba_string_swigregister, METH_O, NULL},
	 { "make_taa_tgba_string", _wrap_make_taa_tgba_string, METH_O, NULL},
	 { "delete_taa_tgba_formula", _wrap_delete_taa_tgba_formula, METH_O, NULL},
	 { "taa_tgba_formula_swigregister", taa_tgba_formula_swigregister, METH_O, NULL},
	 { "make_taa_tgba_formula", _wrap_make_taa_tgba_formula, METH_O, NULL},
	 { "new_state_product", _wrap_new_state_product, METH_VARARGS, NULL},
	 { "state_product_left", _wrap_state_product_left, METH_O, NULL},
	 { "state_product_right", _wrap_state_product_right, METH_O, NULL},
	 { "state_product_clone", _wrap_state_product_clone, METH_O, NULL},
	 { "state_product_swigregister", state_product_swigregister, METH_O, NULL},
	 { "state_product_swiginit", state_product_swiginit, METH_VARARGS, NULL},
	 { "new_twa_product", _wrap_new_twa_product, METH_VARARGS, NULL},
	 { "delete_twa_product", _wrap_delete_twa_product, METH_O, NULL},
	 { "twa_product_left_acc", _wrap_twa_product_left_acc, METH_O, NULL},
	 { "twa_product_right_acc", _wrap_twa_product_right_acc, METH_O, NULL},
	 { "twa_product_swigregister", twa_product_swigregister, METH_O, NULL},
	 { "twa_product_swiginit", twa_product_swiginit, METH_VARARGS, NULL},
	 { "new_twa_product_init", _wrap_new_twa_product_init, METH_VARARGS, NULL},
	 { "delete_twa_product_init", _wrap_delete_twa_product_init, METH_O, NULL},
	 { "twa_product_init_swigregister", twa_product_init_swigregister, METH_O, NULL},
	 { "twa_product_init_swiginit", twa_product_init_swiginit, METH_VARARGS, NULL},
	 { "otf_product", _wrap_otf_product, METH_VARARGS, NULL},
	 { "otf_product_at", _wrap_otf_product_at, METH_VARARGS, NULL},
	 { "new_const_universal_dests", _wrap_new_const_universal_dests, METH_VARARGS, NULL},
	 { "const_universal_dests_begin", _wrap_const_universal_dests_begin, METH_O, NULL},
	 { "const_universal_dests_end", _wrap_const_universal_dests_end, METH_O, NULL},
	 { "const_universal_dests___iter__", _wrap_const_universal_dests___iter__, METH_O, NULL},
	 { "delete_const_universal_dests", _wrap_delete_const_universal_dests, METH_O, NULL},
	 { "const_universal_dests_swigregister", const_universal_dests_swigregister, METH_O, NULL},
	 { "const_universal_dests_swiginit", const_universal_dests_swiginit, METH_VARARGS, NULL},
	 { "new_twa_graph_state", _wrap_new_twa_graph_state, METH_VARARGS, NULL},
	 { "delete_twa_graph_state", _wrap_delete_twa_graph_state, METH_O, NULL},
	 { "twa_graph_state_clone", _wrap_twa_graph_state_clone, METH_O, NULL},
	 { "twa_graph_state_swigregister", twa_graph_state_swigregister, METH_O, NULL},
	 { "twa_graph_state_swiginit", twa_graph_state_swiginit, METH_VARARGS, NULL},
	 { "twa_graph_edge_data_cond_set", _wrap_twa_graph_edge_data_cond_set, METH_VARARGS, NULL},
	 { "twa_graph_edge_data_cond_get", _wrap_twa_graph_edge_data_cond_get, METH_O, NULL},
	 { "twa_graph_edge_data_acc_set", _wrap_twa_graph_edge_data_acc_set, METH_VARARGS, NULL},
	 { "twa_graph_edge_data_acc_get", _wrap_twa_graph_edge_data_acc_get, METH_O, NULL},
	 { "new_twa_graph_edge_data", _wrap_new_twa_graph_edge_data, METH_VARARGS, NULL},
	 { "twa_graph_edge_data___lt__", _wrap_twa_graph_edge_data___lt__, METH_VARARGS, NULL},
	 { "twa_graph_edge_data___eq__", _wrap_twa_graph_edge_data___eq__, METH_VARARGS, NULL},
	 { "delete_twa_graph_edge_data", _wrap_delete_twa_graph_edge_data, METH_O, NULL},
	 { "twa_graph_edge_data_swigregister", twa_graph_edge_data_swigregister, METH_O, NULL},
	 { "twa_graph_edge_data_swiginit", twa_graph_edge_data_swiginit, METH_VARARGS, NULL},
	 { "twa_graph_apply_permutation", _wrap_twa_graph_apply_permutation, METH_VARARGS, NULL},
	 { "new_twa_graph", _wrap_new_twa_graph, METH_VARARGS, NULL},
	 { "delete_twa_graph", _wrap_delete_twa_graph, METH_O, NULL},
	 { "twa_graph_get_graph", _wrap_twa_graph_get_graph, METH_VARARGS, NULL},
	 { "twa_graph_num_states", _wrap_twa_graph_num_states, METH_O, NULL},
	 { "twa_graph_num_edges", _wrap_twa_graph_num_edges, METH_O, NULL},
	 { "twa_graph_set_init_state", _wrap_twa_graph_set_init_state, METH_VARARGS, NULL},
	 { "twa_graph_get_init_state_number", _wrap_twa_graph_get_init_state_number, METH_O, NULL},
	 { "twa_graph_get_init_state", _wrap_twa_graph_get_init_state, METH_O, NULL},
	 { "twa_graph_is_univ_dest", _wrap_twa_graph_is_univ_dest, METH_VARARGS, NULL},
	 { "twa_graph_state_number", _wrap_twa_graph_state_number, METH_VARARGS, NULL},
	 { "twa_graph_state_from_number", _wrap_twa_graph_state_from_number, METH_VARARGS, NULL},
	 { "twa_graph_format_state", _wrap_twa_graph_format_state, METH_VARARGS, NULL},
	 { "twa_graph_edge_number", _wrap_twa_graph_edge_number, METH_VARARGS, NULL},
	 { "twa_graph_edge_data", _wrap_twa_graph_edge_data, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage", _wrap_twa_graph_edge_storage, METH_VARARGS, NULL},
	 { "twa_graph_new_state", _wrap_twa_graph_new_state, METH_O, NULL},
	 { "twa_graph_new_states", _wrap_twa_graph_new_states, METH_VARARGS, NULL},
	 { "twa_graph_new_edge", _wrap_twa_graph_new_edge, METH_VARARGS, NULL},
	 { "twa_graph_new_acc_edge", _wrap_twa_graph_new_acc_edge, METH_VARARGS, NULL},
	 { "twa_graph_out", _wrap_twa_graph_out, METH_VARARGS, NULL},
	 { "twa_graph_out_iteraser", _wrap_twa_graph_out_iteraser, METH_VARARGS, NULL},
	 { "twa_graph_univ_dests", _wrap_twa_graph_univ_dests, METH_VARARGS, NULL},
	 { "twa_graph_is_existential", _wrap_twa_graph_is_existential, METH_O, NULL},
	 { "twa_graph_edges", _wrap_twa_graph_edges, METH_O, NULL},
	 { "twa_graph_is_dead_edge", _wrap_twa_graph_is_dead_edge, METH_VARARGS, NULL},
	 { "twa_graph_merge_edges", _wrap_twa_graph_merge_edges, METH_O, NULL},
	 { "twa_graph_merge_univ_dests", _wrap_twa_graph_merge_univ_dests, METH_O, NULL},
	 { "twa_graph_merge_states", _wrap_twa_graph_merge_states, METH_VARARGS, NULL},
	 { "twa_graph_merge_states_of", _wrap_twa_graph_merge_states_of, METH_VARARGS, NULL},
	 { "twa_graph_purge_dead_states", _wrap_twa_graph_purge_dead_states, METH_O, NULL},
	 { "twa_graph_purge_unreachable_states", _wrap_twa_graph_purge_unreachable_states, METH_VARARGS, NULL},
	 { "twa_graph_remove_unused_ap", _wrap_twa_graph_remove_unused_ap, METH_O, NULL},
	 { "twa_graph_copy_state_names_from", _wrap_twa_graph_copy_state_names_from, METH_VARARGS, NULL},
	 { "twa_graph_state_acc_sets", _wrap_twa_graph_state_acc_sets, METH_VARARGS, NULL},
	 { "twa_graph_state_is_accepting", _wrap_twa_graph_state_is_accepting, METH_VARARGS, NULL},
	 { "twa_graph___eq__", _wrap_twa_graph___eq__, METH_VARARGS, NULL},
	 { "twa_graph_kill_state", _wrap_twa_graph_kill_state, METH_VARARGS, NULL},
	 { "twa_graph_dump_storage_as_dot", _wrap_twa_graph_dump_storage_as_dot, METH_VARARGS, NULL},
	 { "twa_graph_new_univ_edge", _wrap_twa_graph_new_univ_edge, METH_VARARGS, NULL},
	 { "twa_graph_set_univ_init_state", _wrap_twa_graph_set_univ_init_state, METH_VARARGS, NULL},
	 { "twa_graph_report_univ_dest", _wrap_twa_graph_report_univ_dest, METH_VARARGS, NULL},
	 { "twa_graph_swigregister", twa_graph_swigregister, METH_O, NULL},
	 { "twa_graph_swiginit", twa_graph_swiginit, METH_VARARGS, NULL},
	 { "make_twa_graph", _wrap_make_twa_graph, METH_VARARGS, NULL},
	 { "new_twa_graph_state_out", _wrap_new_twa_graph_state_out, METH_VARARGS, NULL},
	 { "twa_graph_state_out_begin", _wrap_twa_graph_state_out_begin, METH_O, NULL},
	 { "twa_graph_state_out_end", _wrap_twa_graph_state_out_end, METH_O, NULL},
	 { "twa_graph_state_out_recycle", _wrap_twa_graph_state_out_recycle, METH_VARARGS, NULL},
	 { "twa_graph_state_out___iter__", _wrap_twa_graph_state_out___iter__, METH_O, NULL},
	 { "delete_twa_graph_state_out", _wrap_delete_twa_graph_state_out, METH_O, NULL},
	 { "twa_graph_state_out_swigregister", twa_graph_state_out_swigregister, METH_O, NULL},
	 { "twa_graph_state_out_swiginit", twa_graph_state_out_swiginit, METH_VARARGS, NULL},
	 { "new_twa_graph_killer_edge_iterator", _wrap_new_twa_graph_killer_edge_iterator, METH_VARARGS, NULL},
	 { "twa_graph_killer_edge_iterator_erase", _wrap_twa_graph_killer_edge_iterator_erase, METH_O, NULL},
	 { "twa_graph_killer_edge_iterator_current", _wrap_twa_graph_killer_edge_iterator_current, METH_O, NULL},
	 { "twa_graph_killer_edge_iterator_advance", _wrap_twa_graph_killer_edge_iterator_advance, METH_O, NULL},
	 { "twa_graph_killer_edge_iterator___bool__", _wrap_twa_graph_killer_edge_iterator___bool__, METH_O, NULL},
	 { "delete_twa_graph_killer_edge_iterator", _wrap_delete_twa_graph_killer_edge_iterator, METH_O, NULL},
	 { "twa_graph_killer_edge_iterator_swigregister", twa_graph_killer_edge_iterator_swigregister, METH_O, NULL},
	 { "twa_graph_killer_edge_iterator_swiginit", twa_graph_killer_edge_iterator_swiginit, METH_VARARGS, NULL},
	 { "new_twa_graph_all_trans", _wrap_new_twa_graph_all_trans, METH_O, NULL},
	 { "twa_graph_all_trans_begin", _wrap_twa_graph_all_trans_begin, METH_O, NULL},
	 { "twa_graph_all_trans_end", _wrap_twa_graph_all_trans_end, METH_O, NULL},
	 { "twa_graph_all_trans___iter__", _wrap_twa_graph_all_trans___iter__, METH_O, NULL},
	 { "delete_twa_graph_all_trans", _wrap_delete_twa_graph_all_trans, METH_O, NULL},
	 { "twa_graph_all_trans_swigregister", twa_graph_all_trans_swigregister, METH_O, NULL},
	 { "twa_graph_all_trans_swiginit", twa_graph_all_trans_swiginit, METH_VARARGS, NULL},
	 { "new_twa_graph_edge_boxed_data", _wrap_new_twa_graph_edge_boxed_data, METH_NOARGS, NULL},
	 { "twa_graph_edge_boxed_data_data", _wrap_twa_graph_edge_boxed_data_data, METH_VARARGS, NULL},
	 { "delete_twa_graph_edge_boxed_data", _wrap_delete_twa_graph_edge_boxed_data, METH_O, NULL},
	 { "twa_graph_edge_boxed_data_swigregister", twa_graph_edge_boxed_data_swigregister, METH_O, NULL},
	 { "twa_graph_edge_boxed_data_swiginit", twa_graph_edge_boxed_data_swiginit, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage_dst_set", _wrap_twa_graph_edge_storage_dst_set, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage_dst_get", _wrap_twa_graph_edge_storage_dst_get, METH_O, NULL},
	 { "twa_graph_edge_storage_next_succ_set", _wrap_twa_graph_edge_storage_next_succ_set, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage_next_succ_get", _wrap_twa_graph_edge_storage_next_succ_get, METH_O, NULL},
	 { "twa_graph_edge_storage_src_set", _wrap_twa_graph_edge_storage_src_set, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage_src_get", _wrap_twa_graph_edge_storage_src_get, METH_O, NULL},
	 { "new_twa_graph_edge_storage", _wrap_new_twa_graph_edge_storage, METH_NOARGS, NULL},
	 { "twa_graph_edge_storage___lt__", _wrap_twa_graph_edge_storage___lt__, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage___eq__", _wrap_twa_graph_edge_storage___eq__, METH_VARARGS, NULL},
	 { "delete_twa_graph_edge_storage", _wrap_delete_twa_graph_edge_storage, METH_O, NULL},
	 { "twa_graph_edge_storage_swigregister", twa_graph_edge_storage_swigregister, METH_O, NULL},
	 { "twa_graph_edge_storage_swiginit", twa_graph_edge_storage_swiginit, METH_VARARGS, NULL},
	 { "new_aig", _wrap_new_aig, METH_VARARGS, NULL},
	 { "delete_aig", _wrap_delete_aig, METH_O, NULL},
	 { "aig_get_safe_point_", _wrap_aig_get_safe_point_, METH_O, NULL},
	 { "aig_roll_back_", _wrap_aig_roll_back_, METH_VARARGS, NULL},
	 { "aig_reapply_", _wrap_aig_reapply_, METH_VARARGS, NULL},
	 { "aig_num_outputs", _wrap_aig_num_outputs, METH_O, NULL},
	 { "aig_outputs", _wrap_aig_outputs, METH_O, NULL},
	 { "aig_output_names", _wrap_aig_output_names, METH_O, NULL},
	 { "aig_num_inputs", _wrap_aig_num_inputs, METH_O, NULL},
	 { "aig_input_names", _wrap_aig_input_names, METH_O, NULL},
	 { "aig_num_latches", _wrap_aig_num_latches, METH_O, NULL},
	 { "aig_next_latches", _wrap_aig_next_latches, METH_O, NULL},
	 { "aig_num_gates", _wrap_aig_num_gates, METH_O, NULL},
	 { "aig_gates", _wrap_aig_gates, METH_O, NULL},
	 { "aig_max_var", _wrap_aig_max_var, METH_O, NULL},
	 { "aig_input_var", _wrap_aig_input_var, METH_VARARGS, NULL},
	 { "aig_input_bdd", _wrap_aig_input_bdd, METH_VARARGS, NULL},
	 { "aig_latch_var", _wrap_aig_latch_var, METH_VARARGS, NULL},
	 { "aig_latch_bdd", _wrap_aig_latch_bdd, METH_VARARGS, NULL},
	 { "aig_gate_var", _wrap_aig_gate_var, METH_VARARGS, NULL},
	 { "aig_gate_bdd", _wrap_aig_gate_bdd, METH_VARARGS, NULL},
	 { "aig_aigvar2bdd", _wrap_aig_aigvar2bdd, METH_VARARGS, NULL},
	 { "aig_bdd2aigvar", _wrap_aig_bdd2aigvar, METH_VARARGS, NULL},
	 { "aig_bdd2INFvar", _wrap_aig_bdd2INFvar, METH_VARARGS, NULL},
	 { "aig_bdd2ISOPvar", _wrap_aig_bdd2ISOPvar, METH_VARARGS, NULL},
	 { "aig_encode_bdd", _wrap_aig_encode_bdd, METH_VARARGS, NULL},
	 { "aig_set_output", _wrap_aig_set_output, METH_VARARGS, NULL},
	 { "aig_set_next_latch", _wrap_aig_set_next_latch, METH_VARARGS, NULL},
	 { "aig_aig_true", _wrap_aig_aig_true, METH_NOARGS, NULL},
	 { "aig_aig_false", _wrap_aig_aig_false, METH_NOARGS, NULL},
	 { "aig_aig_not", _wrap_aig_aig_not, METH_VARARGS, NULL},
	 { "aig_aig_and", _wrap_aig_aig_and, METH_VARARGS, NULL},
	 { "aig_aig_or", _wrap_aig_aig_or, METH_VARARGS, NULL},
	 { "aig_aig_pos", _wrap_aig_aig_pos, METH_VARARGS, NULL},
	 { "aig_encode_all_bdds", _wrap_aig_encode_all_bdds, METH_VARARGS, NULL},
	 { "aig_parse_aag", _wrap_aig_parse_aag, METH_VARARGS, NULL},
	 { "aig_as_automaton", _wrap_aig_as_automaton, METH_VARARGS, NULL},
	 { "aig_circ_state", _wrap_aig_circ_state, METH_O, NULL},
	 { "aig_circ_state_of", _wrap_aig_circ_state_of, METH_VARARGS, NULL},
	 { "aig_circ_init", _wrap_aig_circ_init, METH_O, NULL},
	 { "aig_circ_step", _wrap_aig_circ_step, METH_VARARGS, NULL},
	 { "aig_swigregister", aig_swigregister, METH_O, NULL},
	 { "aig_swiginit", aig_swiginit, METH_VARARGS, NULL},
	 { "mealy_machine_to_aig", _wrap_mealy_machine_to_aig, METH_VARARGS, NULL},
	 { "mealy_machines_to_aig", _wrap_mealy_machines_to_aig, METH_VARARGS, NULL},
	 { "print_aiger", _wrap_print_aiger, METH_VARARGS, NULL},
	 { "new_outedge_combiner", _wrap_new_outedge_combiner, METH_O, NULL},
	 { "delete_outedge_combiner", _wrap_delete_outedge_combiner, METH_O, NULL},
	 { "outedge_combiner___call__", _wrap_outedge_combiner___call__, METH_VARARGS, NULL},
	 { "outedge_combiner_new_dests", _wrap_outedge_combiner_new_dests, METH_VARARGS, NULL},
	 { "outedge_combiner_swigregister", outedge_combiner_swigregister, METH_O, NULL},
	 { "outedge_combiner_swiginit", outedge_combiner_swiginit, METH_VARARGS, NULL},
	 { "remove_alternation", _wrap_remove_alternation, METH_VARARGS, NULL},
	 { "new_univ_remover_state", _wrap_new_univ_remover_state, METH_VARARGS, NULL},
	 { "univ_remover_state_states", _wrap_univ_remover_state_states, METH_O, NULL},
	 { "univ_remover_state_is_reset", _wrap_univ_remover_state_is_reset, METH_O, NULL},
	 { "delete_univ_remover_state", _wrap_delete_univ_remover_state, METH_O, NULL},
	 { "univ_remover_state_swigregister", univ_remover_state_swigregister, METH_O, NULL},
	 { "univ_remover_state_swiginit", univ_remover_state_swiginit, METH_VARARGS, NULL},
	 { "new_twa_univ_remover", _wrap_new_twa_univ_remover, METH_O, NULL},
	 { "twa_univ_remover_allocate_state_vars", _wrap_twa_univ_remover_allocate_state_vars, METH_O, NULL},
	 { "delete_twa_univ_remover", _wrap_delete_twa_univ_remover, METH_O, NULL},
	 { "twa_univ_remover_swigregister", twa_univ_remover_swigregister, METH_O, NULL},
	 { "twa_univ_remover_swiginit", twa_univ_remover_swiginit, METH_VARARGS, NULL},
	 { "remove_univ_otf", _wrap_remove_univ_otf, METH_O, NULL},
	 { "cleanup_acceptance_here", _wrap_cleanup_acceptance_here, METH_VARARGS, NULL},
	 { "cleanup_acceptance", _wrap_cleanup_acceptance, METH_VARARGS, NULL},
	 { "simplify_acceptance_here", _wrap_simplify_acceptance_here, METH_O, NULL},
	 { "simplify_acceptance", _wrap_simplify_acceptance, METH_O, NULL},
	 { "nca_st_info_clause_num_set", _wrap_nca_st_info_clause_num_set, METH_VARARGS, NULL},
	 { "nca_st_info_clause_num_get", _wrap_nca_st_info_clause_num_get, METH_O, NULL},
	 { "nca_st_info_state_num_set", _wrap_nca_st_info_state_num_set, METH_VARARGS, NULL},
	 { "nca_st_info_state_num_get", _wrap_nca_st_info_state_num_get, METH_O, NULL},
	 { "nca_st_info_all_dst_set", _wrap_nca_st_info_all_dst_set, METH_VARARGS, NULL},
	 { "nca_st_info_all_dst_get", _wrap_nca_st_info_all_dst_get, METH_O, NULL},
	 { "new_nca_st_info", _wrap_new_nca_st_info, METH_VARARGS, NULL},
	 { "delete_nca_st_info", _wrap_delete_nca_st_info, METH_O, NULL},
	 { "nca_st_info_swigregister", nca_st_info_swigregister, METH_O, NULL},
	 { "nca_st_info_swiginit", nca_st_info_swiginit, METH_VARARGS, NULL},
	 { "nsa_to_nca", _wrap_nsa_to_nca, METH_VARARGS, NULL},
	 { "dnf_to_nca", _wrap_dnf_to_nca, METH_VARARGS, NULL},
	 { "to_nca", _wrap_to_nca, METH_VARARGS, NULL},
	 { "nsa_to_dca", _wrap_nsa_to_dca, METH_VARARGS, NULL},
	 { "dnf_to_dca", _wrap_dnf_to_dca, METH_VARARGS, NULL},
	 { "to_dca", _wrap_to_dca, METH_VARARGS, NULL},
	 { "copy", _wrap_copy, METH_VARARGS, NULL},
	 { "complete_here", _wrap_complete_here, METH_O, NULL},
	 { "complete", _wrap_complete, METH_O, NULL},
	 { "delay_branching_here", _wrap_delay_branching_here, METH_O, NULL},
	 { "degeneralize", _wrap_degeneralize, METH_VARARGS, NULL},
	 { "degeneralize_tba", _wrap_degeneralize_tba, METH_VARARGS, NULL},
	 { "partial_degeneralize", _wrap_partial_degeneralize, METH_VARARGS, NULL},
	 { "is_partially_degeneralizable", _wrap_is_partially_degeneralizable, METH_VARARGS, NULL},
	 { "propagate_marks_vector", _wrap_propagate_marks_vector, METH_VARARGS, NULL},
	 { "propagate_marks_here", _wrap_propagate_marks_here, METH_VARARGS, NULL},
	 { "tgba_determinize", _wrap_tgba_determinize, METH_VARARGS, NULL},
	 { "dualize", _wrap_dualize, METH_O, NULL},
	 { "new_emptiness_check_result", _wrap_new_emptiness_check_result, METH_VARARGS, NULL},
	 { "delete_emptiness_check_result", _wrap_delete_emptiness_check_result, METH_O, NULL},
	 { "emptiness_check_result_accepting_run", _wrap_emptiness_check_result_accepting_run, METH_O, NULL},
	 { "emptiness_check_result_automaton", _wrap_emptiness_check_result_automaton, METH_O, NULL},
	 { "emptiness_check_result_options", _wrap_emptiness_check_result_options, METH_O, NULL},
	 { "emptiness_check_result_parse_options", _wrap_emptiness_check_result_parse_options, METH_VARARGS, NULL},
	 { "emptiness_check_result_statistics", _wrap_emptiness_check_result_statistics, METH_O, NULL},
	 { "emptiness_check_result_swigregister", emptiness_check_result_swigregister, METH_O, NULL},
	 { "emptiness_check_result_swiginit", emptiness_check_result_swiginit, METH_VARARGS, NULL},
	 { "delete_emptiness_check", _wrap_delete_emptiness_check, METH_O, NULL},
	 { "emptiness_check_automaton", _wrap_emptiness_check_automaton, METH_O, NULL},
	 { "emptiness_check_options", _wrap_emptiness_check_options, METH_O, NULL},
	 { "emptiness_check_parse_options", _wrap_emptiness_check_parse_options, METH_VARARGS, NULL},
	 { "emptiness_check_safe", _wrap_emptiness_check_safe, METH_O, NULL},
	 { "emptiness_check_check", _wrap_emptiness_check_check, METH_O, NULL},
	 { "emptiness_check_statistics", _wrap_emptiness_check_statistics, METH_O, NULL},
	 { "emptiness_check_emptiness_check_statistics", _wrap_emptiness_check_emptiness_check_statistics, METH_O, NULL},
	 { "emptiness_check_print_stats", _wrap_emptiness_check_print_stats, METH_VARARGS, NULL},
	 { "emptiness_check_options_updated", _wrap_emptiness_check_options_updated, METH_VARARGS, NULL},
	 { "emptiness_check_swigregister", emptiness_check_swigregister, METH_O, NULL},
	 { "emptiness_check_instantiator_instantiate", _wrap_emptiness_check_instantiator_instantiate, METH_VARARGS, NULL},
	 { "emptiness_check_instantiator_options", _wrap_emptiness_check_instantiator_options, METH_VARARGS, NULL},
	 { "emptiness_check_instantiator_min_sets", _wrap_emptiness_check_instantiator_min_sets, METH_O, NULL},
	 { "emptiness_check_instantiator_max_sets", _wrap_emptiness_check_instantiator_max_sets, METH_O, NULL},
	 { "delete_emptiness_check_instantiator", _wrap_delete_emptiness_check_instantiator, METH_O, NULL},
	 { "emptiness_check_instantiator_swigregister", emptiness_check_instantiator_swigregister, METH_O, NULL},
	 { "make_emptiness_check_instantiator", _wrap_make_emptiness_check_instantiator, METH_O, NULL},
	 { "twa_run_prefix_set", _wrap_twa_run_prefix_set, METH_VARARGS, NULL},
	 { "twa_run_prefix_get", _wrap_twa_run_prefix_get, METH_O, NULL},
	 { "twa_run_cycle_set", _wrap_twa_run_cycle_set, METH_VARARGS, NULL},
	 { "twa_run_cycle_get", _wrap_twa_run_cycle_get, METH_O, NULL},
	 { "twa_run_aut_set", _wrap_twa_run_aut_set, METH_VARARGS, NULL},
	 { "twa_run_aut_get", _wrap_twa_run_aut_get, METH_O, NULL},
	 { "delete_twa_run", _wrap_delete_twa_run, METH_O, NULL},
	 { "new_twa_run", _wrap_new_twa_run, METH_VARARGS, NULL},
	 { "twa_run_ensure_non_empty_cycle", _wrap_twa_run_ensure_non_empty_cycle, METH_VARARGS, NULL},
	 { "twa_run_reduce", _wrap_twa_run_reduce, METH_O, NULL},
	 { "twa_run_project", _wrap_twa_run_project, METH_VARARGS, NULL},
	 { "twa_run_replay", _wrap_twa_run_replay, METH_VARARGS, NULL},
	 { "twa_run_highlight", _wrap_twa_run_highlight, METH_VARARGS, NULL},
	 { "twa_run_as_twa", _wrap_twa_run_as_twa, METH_VARARGS, NULL},
	 { "twa_run___str__", _wrap_twa_run___str__, METH_O, NULL},
	 { "twa_run_swigregister", twa_run_swigregister, METH_O, NULL},
	 { "twa_run_swiginit", twa_run_swiginit, METH_VARARGS, NULL},
	 { "step_s_set", _wrap_step_s_set, METH_VARARGS, NULL},
	 { "step_s_get", _wrap_step_s_get, METH_O, NULL},
	 { "step_label_set", _wrap_step_label_set, METH_VARARGS, NULL},
	 { "step_label_get", _wrap_step_label_get, METH_O, NULL},
	 { "step_acc_set", _wrap_step_acc_set, METH_VARARGS, NULL},
	 { "step_acc_get", _wrap_step_acc_get, METH_O, NULL},
	 { "new_step", _wrap_new_step, METH_VARARGS, NULL},
	 { "delete_step", _wrap_delete_step, METH_O, NULL},
	 { "step_swigregister", step_swigregister, METH_O, NULL},
	 { "step_swiginit", step_swiginit, METH_VARARGS, NULL},
	 { "list_step_iterator", _wrap_list_step_iterator, METH_O, NULL},
	 { "list_step___nonzero__", _wrap_list_step___nonzero__, METH_O, NULL},
	 { "list_step___bool__", _wrap_list_step___bool__, METH_O, NULL},
	 { "list_step___len__", _wrap_list_step___len__, METH_O, NULL},
	 { "list_step___getslice__", _wrap_list_step___getslice__, METH_VARARGS, NULL},
	 { "list_step___setslice__", _wrap_list_step___setslice__, METH_VARARGS, NULL},
	 { "list_step___delslice__", _wrap_list_step___delslice__, METH_VARARGS, NULL},
	 { "list_step___delitem__", _wrap_list_step___delitem__, METH_VARARGS, NULL},
	 { "list_step___getitem__", _wrap_list_step___getitem__, METH_VARARGS, NULL},
	 { "list_step___setitem__", _wrap_list_step___setitem__, METH_VARARGS, NULL},
	 { "list_step_pop", _wrap_list_step_pop, METH_O, NULL},
	 { "list_step_append", _wrap_list_step_append, METH_VARARGS, NULL},
	 { "list_step_empty", _wrap_list_step_empty, METH_O, NULL},
	 { "list_step_size", _wrap_list_step_size, METH_O, NULL},
	 { "list_step_swap", _wrap_list_step_swap, METH_VARARGS, NULL},
	 { "list_step_begin", _wrap_list_step_begin, METH_O, NULL},
	 { "list_step_end", _wrap_list_step_end, METH_O, NULL},
	 { "list_step_rbegin", _wrap_list_step_rbegin, METH_O, NULL},
	 { "list_step_rend", _wrap_list_step_rend, METH_O, NULL},
	 { "list_step_clear", _wrap_list_step_clear, METH_O, NULL},
	 { "list_step_get_allocator", _wrap_list_step_get_allocator, METH_O, NULL},
	 { "list_step_pop_back", _wrap_list_step_pop_back, METH_O, NULL},
	 { "list_step_erase", _wrap_list_step_erase, METH_VARARGS, NULL},
	 { "new_list_step", _wrap_new_list_step, METH_VARARGS, NULL},
	 { "list_step_push_back", _wrap_list_step_push_back, METH_VARARGS, NULL},
	 { "list_step_front", _wrap_list_step_front, METH_O, NULL},
	 { "list_step_back", _wrap_list_step_back, METH_O, NULL},
	 { "list_step_assign", _wrap_list_step_assign, METH_VARARGS, NULL},
	 { "list_step_resize", _wrap_list_step_resize, METH_VARARGS, NULL},
	 { "list_step_insert", _wrap_list_step_insert, METH_VARARGS, NULL},
	 { "list_step_pop_front", _wrap_list_step_pop_front, METH_O, NULL},
	 { "list_step_push_front", _wrap_list_step_push_front, METH_VARARGS, NULL},
	 { "list_step_reverse", _wrap_list_step_reverse, METH_O, NULL},
	 { "delete_list_step", _wrap_delete_list_step, METH_O, NULL},
	 { "list_step_swigregister", list_step_swigregister, METH_O, NULL},
	 { "list_step_swiginit", list_step_swiginit, METH_VARARGS, NULL},
	 { "couvreur99", _wrap_couvreur99, METH_VARARGS, NULL},
	 { "generic_emptiness_check", _wrap_generic_emptiness_check, METH_O, NULL},
	 { "generic_accepting_run", _wrap_generic_accepting_run, METH_O, NULL},
	 { "generic_emptiness_check_for_scc", _wrap_generic_emptiness_check_for_scc, METH_VARARGS, NULL},
	 { "generic_emptiness_check_select_version", _wrap_generic_emptiness_check_select_version, METH_VARARGS, NULL},
	 { "accepting_transitions_scc", _wrap_accepting_transitions_scc, METH_VARARGS, NULL},
	 { "accepting_transitions", _wrap_accepting_transitions, METH_VARARGS, NULL},
	 { "print_lbtt", _wrap_print_lbtt, METH_VARARGS, NULL},
	 { "ltl_to_taa", _wrap_ltl_to_taa, METH_VARARGS, NULL},
	 { "ltl_to_tgba_fm", _wrap_ltl_to_tgba_fm, METH_VARARGS, NULL},
	 { "g_f_terminal_inplace", _wrap_g_f_terminal_inplace, METH_VARARGS, NULL},
	 { "gf_guarantee_to_ba_maybe", _wrap_gf_guarantee_to_ba_maybe, METH_VARARGS, NULL},
	 { "gf_guarantee_to_ba", _wrap_gf_guarantee_to_ba, METH_VARARGS, NULL},
	 { "fg_safety_to_dca_maybe", _wrap_fg_safety_to_dca_maybe, METH_VARARGS, NULL},
	 { "fg_safety_to_dca", _wrap_fg_safety_to_dca, METH_VARARGS, NULL},
	 { "compsusp", _wrap_compsusp, METH_VARARGS, NULL},
	 { "contains", _wrap_contains, METH_VARARGS, NULL},
	 { "are_equivalent", _wrap_are_equivalent, METH_VARARGS, NULL},
	 { "language_map", _wrap_language_map, METH_O, NULL},
	 { "highlight_languages", _wrap_highlight_languages, METH_O, NULL},
	 { "explicit_magic_search", _wrap_explicit_magic_search, METH_VARARGS, NULL},
	 { "bit_state_hashing_magic_search", _wrap_bit_state_hashing_magic_search, METH_VARARGS, NULL},
	 { "magic_search", _wrap_magic_search, METH_VARARGS, NULL},
	 { "minimize_monitor", _wrap_minimize_monitor, METH_O, NULL},
	 { "minimize_wdba", _wrap_minimize_wdba, METH_VARARGS, NULL},
	 { "minimize_obligation", _wrap_minimize_obligation, METH_VARARGS, NULL},
	 { "minimize_obligation_garanteed_to_work", _wrap_minimize_obligation_garanteed_to_work, METH_VARARGS, NULL},
	 { "is_mealy", _wrap_is_mealy, METH_O, NULL},
	 { "is_separated_mealy", _wrap_is_separated_mealy, METH_O, NULL},
	 { "is_split_mealy", _wrap_is_split_mealy, METH_O, NULL},
	 { "is_input_deterministic_mealy", _wrap_is_input_deterministic_mealy, METH_O, NULL},
	 { "split_separated_mealy", _wrap_split_separated_mealy, METH_O, NULL},
	 { "split_separated_mealy_here", _wrap_split_separated_mealy_here, METH_O, NULL},
	 { "unsplit_mealy", _wrap_unsplit_mealy, METH_O, NULL},
	 { "reduce_mealy", _wrap_reduce_mealy, METH_VARARGS, NULL},
	 { "reduce_mealy_here", _wrap_reduce_mealy_here, METH_VARARGS, NULL},
	 { "minimize_mealy", _wrap_minimize_mealy, METH_VARARGS, NULL},
	 { "is_split_mealy_specialization", _wrap_is_split_mealy_specialization, METH_VARARGS, NULL},
	 { "mealy_product", _wrap_mealy_product, METH_VARARGS, NULL},
	 { "simplify_mealy_here", _wrap_simplify_mealy_here, METH_VARARGS, NULL},
	 { "print_never_claim", _wrap_print_never_claim, METH_VARARGS, NULL},
	 { "randomize", _wrap_randomize, METH_VARARGS, NULL},
	 { "rabin_is_buchi_realizable", _wrap_rabin_is_buchi_realizable, METH_O, NULL},
	 { "rabin_to_buchi_if_realizable", _wrap_rabin_to_buchi_if_realizable, METH_O, NULL},
	 { "rabin_to_buchi_maybe", _wrap_rabin_to_buchi_maybe, METH_O, NULL},
	 { "remove_fin", _wrap_remove_fin, METH_O, NULL},
	 { "remove_ap_add_ap", _wrap_remove_ap_add_ap, METH_VARARGS, NULL},
	 { "remove_ap_empty", _wrap_remove_ap_empty, METH_O, NULL},
	 { "remove_ap_strip", _wrap_remove_ap_strip, METH_VARARGS, NULL},
	 { "new_remove_ap", _wrap_new_remove_ap, METH_NOARGS, NULL},
	 { "delete_remove_ap", _wrap_delete_remove_ap, METH_O, NULL},
	 { "remove_ap_swigregister", remove_ap_swigregister, METH_O, NULL},
	 { "remove_ap_swiginit", remove_ap_swiginit, METH_VARARGS, NULL},
	 { "to_finite", _wrap_to_finite, METH_VARARGS, NULL},
	 { "to_generalized_buchi", _wrap_to_generalized_buchi, METH_O, NULL},
	 { "streett_to_generalized_buchi", _wrap_streett_to_generalized_buchi, METH_O, NULL},
	 { "streett_to_generalized_buchi_maybe", _wrap_streett_to_generalized_buchi_maybe, METH_O, NULL},
	 { "to_generalized_rabin", _wrap_to_generalized_rabin, METH_VARARGS, NULL},
	 { "to_generalized_streett", _wrap_to_generalized_streett, METH_VARARGS, NULL},
	 { "dnf_to_streett", _wrap_dnf_to_streett, METH_VARARGS, NULL},
	 { "sbacc", _wrap_sbacc, METH_O, NULL},
	 { "new_keep_all", _wrap_new_keep_all, METH_NOARGS, NULL},
	 { "delete_keep_all", _wrap_delete_keep_all, METH_O, NULL},
	 { "keep_all_swigregister", keep_all_swigregister, METH_O, NULL},
	 { "keep_all_swiginit", keep_all_swiginit, METH_VARARGS, NULL},
	 { "new_keep_inner_scc", _wrap_new_keep_inner_scc, METH_VARARGS, NULL},
	 { "delete_keep_inner_scc", _wrap_delete_keep_inner_scc, METH_O, NULL},
	 { "keep_inner_scc_swigregister", keep_inner_scc_swigregister, METH_O, NULL},
	 { "keep_inner_scc_swiginit", keep_inner_scc_swiginit, METH_VARARGS, NULL},
	 { "new_scc_info_node", _wrap_new_scc_info_node, METH_VARARGS, NULL},
	 { "scc_info_node_is_trivial", _wrap_scc_info_node_is_trivial, METH_O, NULL},
	 { "scc_info_node_is_accepting", _wrap_scc_info_node_is_accepting, METH_O, NULL},
	 { "scc_info_node_is_rejecting", _wrap_scc_info_node_is_rejecting, METH_O, NULL},
	 { "scc_info_node_is_useful", _wrap_scc_info_node_is_useful, METH_O, NULL},
	 { "scc_info_node_acc_marks", _wrap_scc_info_node_acc_marks, METH_O, NULL},
	 { "scc_info_node_common_marks", _wrap_scc_info_node_common_marks, METH_O, NULL},
	 { "scc_info_node_states", _wrap_scc_info_node_states, METH_O, NULL},
	 { "scc_info_node_one_state", _wrap_scc_info_node_one_state, METH_O, NULL},
	 { "scc_info_node_succ", _wrap_scc_info_node_succ, METH_O, NULL},
	 { "delete_scc_info_node", _wrap_delete_scc_info_node, METH_O, NULL},
	 { "scc_info_node_swigregister", scc_info_node_swigregister, METH_O, NULL},
	 { "scc_info_node_swiginit", scc_info_node_swiginit, METH_VARARGS, NULL},
	 { "__and__", _wrap___and__, METH_VARARGS, NULL},
	 { "__or__", _wrap___or__, METH_VARARGS, NULL},
	 { "new_scc_info_with_options", _wrap_new_scc_info_with_options, METH_VARARGS, NULL},
	 { "new_scc_info", _wrap_new_scc_info, METH_VARARGS, NULL},
	 { "scc_info_get_aut", _wrap_scc_info_get_aut, METH_O, NULL},
	 { "scc_info_get_options", _wrap_scc_info_get_options, METH_O, NULL},
	 { "scc_info_get_filter", _wrap_scc_info_get_filter, METH_O, NULL},
	 { "scc_info_get_filter_data", _wrap_scc_info_get_filter_data, METH_O, NULL},
	 { "scc_info_scc_count", _wrap_scc_info_scc_count, METH_O, NULL},
	 { "scc_info_one_accepting_scc", _wrap_scc_info_one_accepting_scc, METH_O, NULL},
	 { "scc_info_reachable_state", _wrap_scc_info_reachable_state, METH_VARARGS, NULL},
	 { "scc_info_scc_of", _wrap_scc_info_scc_of, METH_VARARGS, NULL},
	 { "scc_info_begin", _wrap_scc_info_begin, METH_O, NULL},
	 { "scc_info_end", _wrap_scc_info_end, METH_O, NULL},
	 { "scc_info_cbegin", _wrap_scc_info_cbegin, METH_O, NULL},
	 { "scc_info_cend", _wrap_scc_info_cend, METH_O, NULL},
	 { "scc_info_rbegin", _wrap_scc_info_rbegin, METH_O, NULL},
	 { "scc_info_rend", _wrap_scc_info_rend, METH_O, NULL},
	 { "scc_info_states_of", _wrap_scc_info_states_of, METH_VARARGS, NULL},
	 { "scc_info_edges_of", _wrap_scc_info_edges_of, METH_VARARGS, NULL},
	 { "scc_info_inner_edges_of", _wrap_scc_info_inner_edges_of, METH_VARARGS, NULL},
	 { "scc_info_one_state_of", _wrap_scc_info_one_state_of, METH_VARARGS, NULL},
	 { "scc_info_initial", _wrap_scc_info_initial, METH_O, NULL},
	 { "scc_info_succ", _wrap_scc_info_succ, METH_VARARGS, NULL},
	 { "scc_info_is_trivial", _wrap_scc_info_is_trivial, METH_VARARGS, NULL},
	 { "scc_info_acc", _wrap_scc_info_acc, METH_VARARGS, NULL},
	 { "scc_info_is_accepting_scc", _wrap_scc_info_is_accepting_scc, METH_VARARGS, NULL},
	 { "scc_info_is_rejecting_scc", _wrap_scc_info_is_rejecting_scc, METH_VARARGS, NULL},
	 { "scc_info_is_maximally_accepting_scc", _wrap_scc_info_is_maximally_accepting_scc, METH_VARARGS, NULL},
	 { "scc_info_determine_unknown_acceptance", _wrap_scc_info_determine_unknown_acceptance, METH_O, NULL},
	 { "scc_info_check_scc_emptiness", _wrap_scc_info_check_scc_emptiness, METH_VARARGS, NULL},
	 { "scc_info_get_accepting_run", _wrap_scc_info_get_accepting_run, METH_VARARGS, NULL},
	 { "scc_info_is_useful_scc", _wrap_scc_info_is_useful_scc, METH_VARARGS, NULL},
	 { "scc_info_is_useful_state", _wrap_scc_info_is_useful_state, METH_VARARGS, NULL},
	 { "scc_info_marks", _wrap_scc_info_marks, METH_O, NULL},
	 { "scc_info_marks_of", _wrap_scc_info_marks_of, METH_VARARGS, NULL},
	 { "scc_info_used_acc", _wrap_scc_info_used_acc, METH_O, NULL},
	 { "scc_info_used_acc_of", _wrap_scc_info_used_acc_of, METH_VARARGS, NULL},
	 { "scc_info_acc_sets_of", _wrap_scc_info_acc_sets_of, METH_VARARGS, NULL},
	 { "scc_info_common_sets_of", _wrap_scc_info_common_sets_of, METH_VARARGS, NULL},
	 { "scc_info_weak_sccs", _wrap_scc_info_weak_sccs, METH_O, NULL},
	 { "scc_info_scc_ap_support", _wrap_scc_info_scc_ap_support, METH_VARARGS, NULL},
	 { "scc_info_split_on_sets", _wrap_scc_info_split_on_sets, METH_VARARGS, NULL},
	 { "scc_info_states_on_acc_cycle_of", _wrap_scc_info_states_on_acc_cycle_of, METH_VARARGS, NULL},
	 { "scc_info___iter__", _wrap_scc_info___iter__, METH_O, NULL},
	 { "delete_scc_info", _wrap_delete_scc_info, METH_O, NULL},
	 { "scc_info_swigregister", scc_info_swigregister, METH_O, NULL},
	 { "scc_info_swiginit", scc_info_swiginit, METH_VARARGS, NULL},
	 { "new_scc_and_mark_filter", _wrap_new_scc_and_mark_filter, METH_VARARGS, NULL},
	 { "delete_scc_and_mark_filter", _wrap_delete_scc_and_mark_filter, METH_O, NULL},
	 { "scc_and_mark_filter_override_acceptance", _wrap_scc_and_mark_filter_override_acceptance, METH_VARARGS, NULL},
	 { "scc_and_mark_filter_restore_acceptance", _wrap_scc_and_mark_filter_restore_acceptance, METH_O, NULL},
	 { "scc_and_mark_filter_get_aut", _wrap_scc_and_mark_filter_get_aut, METH_O, NULL},
	 { "scc_and_mark_filter_start_state", _wrap_scc_and_mark_filter_start_state, METH_O, NULL},
	 { "scc_and_mark_filter_get_filter", _wrap_scc_and_mark_filter_get_filter, METH_O, NULL},
	 { "scc_and_mark_filter_swigregister", scc_and_mark_filter_swigregister, METH_O, NULL},
	 { "scc_and_mark_filter_swiginit", scc_and_mark_filter_swiginit, METH_VARARGS, NULL},
	 { "dump_scc_info_dot", _wrap_dump_scc_info_dot, METH_VARARGS, NULL},
	 { "new_scc_info_scc_edges", _wrap_new_scc_info_scc_edges, METH_VARARGS, NULL},
	 { "scc_info_scc_edges_begin", _wrap_scc_info_scc_edges_begin, METH_O, NULL},
	 { "scc_info_scc_edges_end", _wrap_scc_info_scc_edges_end, METH_O, NULL},
	 { "scc_info_scc_edges___iter__", _wrap_scc_info_scc_edges___iter__, METH_O, NULL},
	 { "delete_scc_info_scc_edges", _wrap_delete_scc_info_scc_edges, METH_O, NULL},
	 { "scc_info_scc_edges_swigregister", scc_info_scc_edges_swigregister, METH_O, NULL},
	 { "scc_info_scc_edges_swiginit", scc_info_scc_edges_swiginit, METH_VARARGS, NULL},
	 { "new_scc_info_inner_scc_edges", _wrap_new_scc_info_inner_scc_edges, METH_VARARGS, NULL},
	 { "scc_info_inner_scc_edges_begin", _wrap_scc_info_inner_scc_edges_begin, METH_O, NULL},
	 { "scc_info_inner_scc_edges_end", _wrap_scc_info_inner_scc_edges_end, METH_O, NULL},
	 { "scc_info_inner_scc_edges___iter__", _wrap_scc_info_inner_scc_edges___iter__, METH_O, NULL},
	 { "delete_scc_info_inner_scc_edges", _wrap_delete_scc_info_inner_scc_edges, METH_O, NULL},
	 { "scc_info_inner_scc_edges_swigregister", scc_info_inner_scc_edges_swigregister, METH_O, NULL},
	 { "scc_info_inner_scc_edges_swiginit", scc_info_inner_scc_edges_swiginit, METH_VARARGS, NULL},
	 { "vector_twa_graph_iterator", _wrap_vector_twa_graph_iterator, METH_O, NULL},
	 { "vector_twa_graph___nonzero__", _wrap_vector_twa_graph___nonzero__, METH_O, NULL},
	 { "vector_twa_graph___bool__", _wrap_vector_twa_graph___bool__, METH_O, NULL},
	 { "vector_twa_graph___len__", _wrap_vector_twa_graph___len__, METH_O, NULL},
	 { "vector_twa_graph___getslice__", _wrap_vector_twa_graph___getslice__, METH_VARARGS, NULL},
	 { "vector_twa_graph___setslice__", _wrap_vector_twa_graph___setslice__, METH_VARARGS, NULL},
	 { "vector_twa_graph___delslice__", _wrap_vector_twa_graph___delslice__, METH_VARARGS, NULL},
	 { "vector_twa_graph___delitem__", _wrap_vector_twa_graph___delitem__, METH_VARARGS, NULL},
	 { "vector_twa_graph___getitem__", _wrap_vector_twa_graph___getitem__, METH_VARARGS, NULL},
	 { "vector_twa_graph___setitem__", _wrap_vector_twa_graph___setitem__, METH_VARARGS, NULL},
	 { "vector_twa_graph_pop", _wrap_vector_twa_graph_pop, METH_O, NULL},
	 { "vector_twa_graph_append", _wrap_vector_twa_graph_append, METH_VARARGS, NULL},
	 { "vector_twa_graph_empty", _wrap_vector_twa_graph_empty, METH_O, NULL},
	 { "vector_twa_graph_size", _wrap_vector_twa_graph_size, METH_O, NULL},
	 { "vector_twa_graph_swap", _wrap_vector_twa_graph_swap, METH_VARARGS, NULL},
	 { "vector_twa_graph_begin", _wrap_vector_twa_graph_begin, METH_O, NULL},
	 { "vector_twa_graph_end", _wrap_vector_twa_graph_end, METH_O, NULL},
	 { "vector_twa_graph_rbegin", _wrap_vector_twa_graph_rbegin, METH_O, NULL},
	 { "vector_twa_graph_rend", _wrap_vector_twa_graph_rend, METH_O, NULL},
	 { "vector_twa_graph_clear", _wrap_vector_twa_graph_clear, METH_O, NULL},
	 { "vector_twa_graph_get_allocator", _wrap_vector_twa_graph_get_allocator, METH_O, NULL},
	 { "vector_twa_graph_pop_back", _wrap_vector_twa_graph_pop_back, METH_O, NULL},
	 { "vector_twa_graph_erase", _wrap_vector_twa_graph_erase, METH_VARARGS, NULL},
	 { "new_vector_twa_graph", _wrap_new_vector_twa_graph, METH_VARARGS, NULL},
	 { "vector_twa_graph_push_back", _wrap_vector_twa_graph_push_back, METH_VARARGS, NULL},
	 { "vector_twa_graph_front", _wrap_vector_twa_graph_front, METH_O, NULL},
	 { "vector_twa_graph_back", _wrap_vector_twa_graph_back, METH_O, NULL},
	 { "vector_twa_graph_assign", _wrap_vector_twa_graph_assign, METH_VARARGS, NULL},
	 { "vector_twa_graph_resize", _wrap_vector_twa_graph_resize, METH_VARARGS, NULL},
	 { "vector_twa_graph_insert", _wrap_vector_twa_graph_insert, METH_VARARGS, NULL},
	 { "vector_twa_graph_reserve", _wrap_vector_twa_graph_reserve, METH_VARARGS, NULL},
	 { "vector_twa_graph_capacity", _wrap_vector_twa_graph_capacity, METH_O, NULL},
	 { "delete_vector_twa_graph", _wrap_delete_vector_twa_graph, METH_O, NULL},
	 { "vector_twa_graph_swigregister", vector_twa_graph_swigregister, METH_O, NULL},
	 { "vector_twa_graph_swiginit", vector_twa_graph_swiginit, METH_VARARGS, NULL},
	 { "is_terminal_automaton", _wrap_is_terminal_automaton, METH_VARARGS, NULL},
	 { "is_weak_automaton", _wrap_is_weak_automaton, METH_VARARGS, NULL},
	 { "is_very_weak_automaton", _wrap_is_very_weak_automaton, METH_VARARGS, NULL},
	 { "is_inherently_weak_automaton", _wrap_is_inherently_weak_automaton, METH_VARARGS, NULL},
	 { "is_safety_automaton", _wrap_is_safety_automaton, METH_VARARGS, NULL},
	 { "is_liveness_automaton", _wrap_is_liveness_automaton, METH_O, NULL},
	 { "check_strength", _wrap_check_strength, METH_VARARGS, NULL},
	 { "decompose_strength", _wrap_decompose_strength, METH_VARARGS, NULL},
	 { "decompose_scc", _wrap_decompose_scc, METH_VARARGS, NULL},
	 { "scc_filter", _wrap_scc_filter, METH_VARARGS, NULL},
	 { "scc_filter_states", _wrap_scc_filter_states, METH_VARARGS, NULL},
	 { "scc_filter_susp", _wrap_scc_filter_susp, METH_VARARGS, NULL},
	 { "twa_statistics_edges_set", _wrap_twa_statistics_edges_set, METH_VARARGS, NULL},
	 { "twa_statistics_edges_get", _wrap_twa_statistics_edges_get, METH_O, NULL},
	 { "twa_statistics_states_set", _wrap_twa_statistics_states_set, METH_VARARGS, NULL},
	 { "twa_statistics_states_get", _wrap_twa_statistics_states_get, METH_O, NULL},
	 { "new_twa_statistics", _wrap_new_twa_statistics, METH_NOARGS, NULL},
	 { "twa_statistics_dump", _wrap_twa_statistics_dump, METH_VARARGS, NULL},
	 { "delete_twa_statistics", _wrap_delete_twa_statistics, METH_O, NULL},
	 { "twa_statistics_swigregister", twa_statistics_swigregister, METH_O, NULL},
	 { "twa_statistics_swiginit", twa_statistics_swiginit, METH_VARARGS, NULL},
	 { "twa_sub_statistics_transitions_set", _wrap_twa_sub_statistics_transitions_set, METH_VARARGS, NULL},
	 { "twa_sub_statistics_transitions_get", _wrap_twa_sub_statistics_transitions_get, METH_O, NULL},
	 { "new_twa_sub_statistics", _wrap_new_twa_sub_statistics, METH_NOARGS, NULL},
	 { "twa_sub_statistics_dump", _wrap_twa_sub_statistics_dump, METH_VARARGS, NULL},
	 { "delete_twa_sub_statistics", _wrap_delete_twa_sub_statistics, METH_O, NULL},
	 { "twa_sub_statistics_swigregister", twa_sub_statistics_swigregister, METH_O, NULL},
	 { "twa_sub_statistics_swiginit", twa_sub_statistics_swiginit, METH_VARARGS, NULL},
	 { "sub_stats_reachable", _wrap_sub_stats_reachable, METH_O, NULL},
	 { "count_all_transitions", _wrap_count_all_transitions, METH_O, NULL},
	 { "printable_formula__print", _wrap_printable_formula__print, METH_VARARGS, NULL},
	 { "new_printable_formula", _wrap_new_printable_formula, METH_NOARGS, NULL},
	 { "delete_printable_formula", _wrap_delete_printable_formula, METH_O, NULL},
	 { "printable_formula_swigregister", printable_formula_swigregister, METH_O, NULL},
	 { "printable_formula_swiginit", printable_formula_swiginit, METH_VARARGS, NULL},
	 { "printable_acc_cond__print", _wrap_printable_acc_cond__print, METH_VARARGS, NULL},
	 { "new_printable_acc_cond", _wrap_new_printable_acc_cond, METH_NOARGS, NULL},
	 { "delete_printable_acc_cond", _wrap_delete_printable_acc_cond, METH_O, NULL},
	 { "printable_acc_cond_swigregister", printable_acc_cond_swigregister, METH_O, NULL},
	 { "printable_acc_cond_swiginit", printable_acc_cond_swiginit, METH_VARARGS, NULL},
	 { "printable_scc_info_automaton", _wrap_printable_scc_info_automaton, METH_VARARGS, NULL},
	 { "printable_scc_info_reset", _wrap_printable_scc_info_reset, METH_O, NULL},
	 { "printable_scc_info__print", _wrap_printable_scc_info__print, METH_VARARGS, NULL},
	 { "new_printable_scc_info", _wrap_new_printable_scc_info, METH_NOARGS, NULL},
	 { "delete_printable_scc_info", _wrap_delete_printable_scc_info, METH_O, NULL},
	 { "printable_scc_info_swigregister", printable_scc_info_swigregister, METH_O, NULL},
	 { "printable_scc_info_swiginit", printable_scc_info_swiginit, METH_VARARGS, NULL},
	 { "printable_size_set", _wrap_printable_size_set, METH_VARARGS, NULL},
	 { "printable_size__print", _wrap_printable_size__print, METH_VARARGS, NULL},
	 { "new_printable_size", _wrap_new_printable_size, METH_NOARGS, NULL},
	 { "delete_printable_size", _wrap_delete_printable_size, METH_O, NULL},
	 { "printable_size_swigregister", printable_size_swigregister, METH_O, NULL},
	 { "printable_size_swiginit", printable_size_swiginit, METH_VARARGS, NULL},
	 { "printable_long_size_set", _wrap_printable_long_size_set, METH_VARARGS, NULL},
	 { "printable_long_size__print", _wrap_printable_long_size__print, METH_VARARGS, NULL},
	 { "new_printable_long_size", _wrap_new_printable_long_size, METH_NOARGS, NULL},
	 { "delete_printable_long_size", _wrap_delete_printable_long_size, METH_O, NULL},
	 { "printable_long_size_swigregister", printable_long_size_swigregister, METH_O, NULL},
	 { "printable_long_size_swiginit", printable_long_size_swiginit, METH_VARARGS, NULL},
	 { "new_stat_printer", _wrap_new_stat_printer, METH_VARARGS, NULL},
	 { "stat_printer__print", _wrap_stat_printer__print, METH_VARARGS, NULL},
	 { "delete_stat_printer", _wrap_delete_stat_printer, METH_O, NULL},
	 { "stat_printer_swigregister", stat_printer_swigregister, METH_O, NULL},
	 { "stat_printer_swiginit", stat_printer_swiginit, METH_VARARGS, NULL},
	 { "count_nondet_states", _wrap_count_nondet_states, METH_O, NULL},
	 { "is_universal", _wrap_is_universal, METH_O, NULL},
	 { "is_deterministic", _wrap_is_deterministic, METH_O, NULL},
	 { "highlight_nondet_states", _wrap_highlight_nondet_states, METH_VARARGS, NULL},
	 { "highlight_nondet_edges", _wrap_highlight_nondet_edges, METH_VARARGS, NULL},
	 { "highlight_semidet_sccs", _wrap_highlight_semidet_sccs, METH_VARARGS, NULL},
	 { "is_complete", _wrap_is_complete, METH_O, NULL},
	 { "is_semi_deterministic", _wrap_is_semi_deterministic, METH_O, NULL},
	 { "semidet_sccs", _wrap_semidet_sccs, METH_O, NULL},
	 { "check_determinism", _wrap_check_determinism, METH_O, NULL},
	 { "count_univbranch_states", _wrap_count_univbranch_states, METH_O, NULL},
	 { "count_univbranch_edges", _wrap_count_univbranch_edges, METH_O, NULL},
	 { "is_colored", _wrap_is_colored, METH_O, NULL},
	 { "is_unambiguous", _wrap_is_unambiguous, METH_O, NULL},
	 { "check_unambiguous", _wrap_check_unambiguous, METH_O, NULL},
	 { "scc_has_rejecting_cycle", _wrap_scc_has_rejecting_cycle, METH_VARARGS, NULL},
	 { "is_inherently_weak_scc", _wrap_is_inherently_weak_scc, METH_VARARGS, NULL},
	 { "is_weak_scc", _wrap_is_weak_scc, METH_VARARGS, NULL},
	 { "is_complete_scc", _wrap_is_complete_scc, METH_VARARGS, NULL},
	 { "is_terminal_scc", _wrap_is_terminal_scc, METH_VARARGS, NULL},
	 { "alternate_players", _wrap_alternate_players, METH_VARARGS, NULL},
	 { "solve_parity_game", _wrap_solve_parity_game, METH_O, NULL},
	 { "solve_safety_game", _wrap_solve_safety_game, METH_O, NULL},
	 { "print_pg", _wrap_print_pg, METH_VARARGS, NULL},
	 { "pg_print", _wrap_pg_print, METH_VARARGS, NULL},
	 { "highlight_strategy", _wrap_highlight_strategy, METH_VARARGS, NULL},
	 { "set_state_players", _wrap_set_state_players, METH_VARARGS, NULL},
	 { "set_state_player", _wrap_set_state_player, METH_VARARGS, NULL},
	 { "get_state_player", _wrap_get_state_player, METH_VARARGS, NULL},
	 { "get_state_players", _wrap_get_state_players, METH_VARARGS, NULL},
	 { "get_strategy", _wrap_get_strategy, METH_O, NULL},
	 { "set_strategy", _wrap_set_strategy, METH_VARARGS, NULL},
	 { "set_synthesis_outputs", _wrap_set_synthesis_outputs, METH_VARARGS, NULL},
	 { "get_synthesis_outputs", _wrap_get_synthesis_outputs, METH_O, NULL},
	 { "get_synthesis_output_aps", _wrap_get_synthesis_output_aps, METH_O, NULL},
	 { "set_state_winners", _wrap_set_state_winners, METH_VARARGS, NULL},
	 { "set_state_winner", _wrap_set_state_winner, METH_VARARGS, NULL},
	 { "get_state_winner", _wrap_get_state_winner, METH_VARARGS, NULL},
	 { "get_state_winners", _wrap_get_state_winners, METH_O, NULL},
	 { "simulation", _wrap_simulation, METH_VARARGS, NULL},
	 { "simulation_sba", _wrap_simulation_sba, METH_VARARGS, NULL},
	 { "cosimulation", _wrap_cosimulation, METH_VARARGS, NULL},
	 { "cosimulation_sba", _wrap_cosimulation_sba, METH_VARARGS, NULL},
	 { "iterated_simulations", _wrap_iterated_simulations, METH_VARARGS, NULL},
	 { "iterated_simulations_sba", _wrap_iterated_simulations_sba, METH_VARARGS, NULL},
	 { "reduce_direct_sim", _wrap_reduce_direct_sim, METH_O, NULL},
	 { "reduce_direct_sim_sba", _wrap_reduce_direct_sim_sba, METH_O, NULL},
	 { "reduce_direct_cosim", _wrap_reduce_direct_cosim, METH_O, NULL},
	 { "reduce_direct_cosim_sba", _wrap_reduce_direct_cosim_sba, METH_O, NULL},
	 { "reduce_iterated", _wrap_reduce_iterated, METH_O, NULL},
	 { "reduce_iterated_sba", _wrap_reduce_iterated_sba, METH_O, NULL},
	 { "change_parity", _wrap_change_parity, METH_VARARGS, NULL},
	 { "change_parity_here", _wrap_change_parity_here, METH_VARARGS, NULL},
	 { "cleanup_parity", _wrap_cleanup_parity, METH_VARARGS, NULL},
	 { "cleanup_parity_here", _wrap_cleanup_parity_here, METH_VARARGS, NULL},
	 { "colorize_parity", _wrap_colorize_parity, METH_VARARGS, NULL},
	 { "colorize_parity_here", _wrap_colorize_parity_here, METH_VARARGS, NULL},
	 { "reduce_parity", _wrap_reduce_parity, METH_VARARGS, NULL},
	 { "reduce_parity_here", _wrap_reduce_parity_here, METH_VARARGS, NULL},
	 { "reduce_parity_data_parity_max_set", _wrap_reduce_parity_data_parity_max_set, METH_VARARGS, NULL},
	 { "reduce_parity_data_parity_max_get", _wrap_reduce_parity_data_parity_max_get, METH_O, NULL},
	 { "reduce_parity_data_parity_odd_set", _wrap_reduce_parity_data_parity_odd_set, METH_VARARGS, NULL},
	 { "reduce_parity_data_parity_odd_get", _wrap_reduce_parity_data_parity_odd_get, METH_O, NULL},
	 { "reduce_parity_data_piprime1_set", _wrap_reduce_parity_data_piprime1_set, METH_VARARGS, NULL},
	 { "reduce_parity_data_piprime1_get", _wrap_reduce_parity_data_piprime1_get, METH_O, NULL},
	 { "reduce_parity_data_piprime2_set", _wrap_reduce_parity_data_piprime2_set, METH_VARARGS, NULL},
	 { "reduce_parity_data_piprime2_get", _wrap_reduce_parity_data_piprime2_get, METH_O, NULL},
	 { "new_reduce_parity_data", _wrap_new_reduce_parity_data, METH_VARARGS, NULL},
	 { "delete_reduce_parity_data", _wrap_delete_reduce_parity_data, METH_O, NULL},
	 { "reduce_parity_data_swigregister", reduce_parity_data_swigregister, METH_O, NULL},
	 { "reduce_parity_data_swiginit", reduce_parity_data_swiginit, METH_VARARGS, NULL},
	 { "new_postprocessor", _wrap_new_postprocessor, METH_VARARGS, NULL},
	 { "postprocessor_set_type", _wrap_postprocessor_set_type, METH_VARARGS, NULL},
	 { "postprocessor_set_pref", _wrap_postprocessor_set_pref, METH_VARARGS, NULL},
	 { "postprocessor_set_level", _wrap_postprocessor_set_level, METH_VARARGS, NULL},
	 { "postprocessor_run", _wrap_postprocessor_run, METH_VARARGS, NULL},
	 { "delete_postprocessor", _wrap_delete_postprocessor, METH_O, NULL},
	 { "postprocessor_swigregister", postprocessor_swigregister, METH_O, NULL},
	 { "postprocessor_swiginit", postprocessor_swiginit, METH_VARARGS, NULL},
	 { "power_map_map__set", _wrap_power_map_map__set, METH_VARARGS, NULL},
	 { "power_map_map__get", _wrap_power_map_map__get, METH_O, NULL},
	 { "power_map_states_of", _wrap_power_map_states_of, METH_VARARGS, NULL},
	 { "new_power_map", _wrap_new_power_map, METH_NOARGS, NULL},
	 { "delete_power_map", _wrap_delete_power_map, METH_O, NULL},
	 { "power_map_swigregister", power_map_swigregister, METH_O, NULL},
	 { "power_map_swiginit", power_map_swiginit, METH_VARARGS, NULL},
	 { "new_output_aborter", _wrap_new_output_aborter, METH_VARARGS, NULL},
	 { "output_aborter_max_states", _wrap_output_aborter_max_states, METH_O, NULL},
	 { "output_aborter_max_edges", _wrap_output_aborter_max_edges, METH_O, NULL},
	 { "output_aborter_too_large", _wrap_output_aborter_too_large, METH_VARARGS, NULL},
	 { "output_aborter_print_reason", _wrap_output_aborter_print_reason, METH_VARARGS, NULL},
	 { "delete_output_aborter", _wrap_delete_output_aborter, METH_O, NULL},
	 { "output_aborter_swigregister", output_aborter_swigregister, METH_O, NULL},
	 { "output_aborter_swiginit", output_aborter_swiginit, METH_VARARGS, NULL},
	 { "tgba_powerset", _wrap_tgba_powerset, METH_VARARGS, NULL},
	 { "tba_determinize", _wrap_tba_determinize, METH_VARARGS, NULL},
	 { "tba_determinize_check", _wrap_tba_determinize_check, METH_VARARGS, NULL},
	 { "product", _wrap_product, METH_VARARGS, NULL},
	 { "product_or", _wrap_product_or, METH_VARARGS, NULL},
	 { "product_xor", _wrap_product_xor, METH_VARARGS, NULL},
	 { "product_xnor", _wrap_product_xnor, METH_VARARGS, NULL},
	 { "product_susp", _wrap_product_susp, METH_VARARGS, NULL},
	 { "product_or_susp", _wrap_product_or_susp, METH_VARARGS, NULL},
	 { "split_edges", _wrap_split_edges, METH_O, NULL},
	 { "sum", _wrap_sum, METH_VARARGS, NULL},
	 { "sum_and", _wrap_sum_and, METH_VARARGS, NULL},
	 { "sl", _wrap_sl, METH_O, NULL},
	 { "sl2_inplace", _wrap_sl2_inplace, METH_O, NULL},
	 { "sl2", _wrap_sl2, METH_O, NULL},
	 { "closure_inplace", _wrap_closure_inplace, METH_O, NULL},
	 { "closure", _wrap_closure, METH_O, NULL},
	 { "is_stutter_invariant", _wrap_is_stutter_invariant, METH_VARARGS, NULL},
	 { "check_stutter_invariance", _wrap_check_stutter_invariance, METH_VARARGS, NULL},
	 { "stutter_invariant_states", _wrap_stutter_invariant_states, METH_VARARGS, NULL},
	 { "highlight_stutter_invariant_states", _wrap_highlight_stutter_invariant_states, METH_VARARGS, NULL},
	 { "stutter_invariant_letters", _wrap_stutter_invariant_letters, METH_VARARGS, NULL},
	 { "is_stutter_invariant_forward_closed", _wrap_is_stutter_invariant_forward_closed, METH_VARARGS, NULL},
	 { "make_stutter_invariant_forward_closed_inplace", _wrap_make_stutter_invariant_forward_closed_inplace, METH_VARARGS, NULL},
	 { "split_2step", _wrap_split_2step, METH_VARARGS, NULL},
	 { "unsplit_2step", _wrap_unsplit_2step, METH_O, NULL},
	 { "new_synthesis_info", _wrap_new_synthesis_info, METH_NOARGS, NULL},
	 { "synthesis_info_force_sbacc_set", _wrap_synthesis_info_force_sbacc_set, METH_VARARGS, NULL},
	 { "synthesis_info_force_sbacc_get", _wrap_synthesis_info_force_sbacc_get, METH_O, NULL},
	 { "synthesis_info_s_set", _wrap_synthesis_info_s_set, METH_VARARGS, NULL},
	 { "synthesis_info_s_get", _wrap_synthesis_info_s_get, METH_O, NULL},
	 { "synthesis_info_minimize_lvl_set", _wrap_synthesis_info_minimize_lvl_set, METH_VARARGS, NULL},
	 { "synthesis_info_minimize_lvl_get", _wrap_synthesis_info_minimize_lvl_get, METH_O, NULL},
	 { "synthesis_info_bv_set", _wrap_synthesis_info_bv_set, METH_VARARGS, NULL},
	 { "synthesis_info_bv_get", _wrap_synthesis_info_bv_get, METH_O, NULL},
	 { "synthesis_info_verbose_stream_set", _wrap_synthesis_info_verbose_stream_set, METH_VARARGS, NULL},
	 { "synthesis_info_verbose_stream_get", _wrap_synthesis_info_verbose_stream_get, METH_O, NULL},
	 { "synthesis_info_opt_set", _wrap_synthesis_info_opt_set, METH_VARARGS, NULL},
	 { "synthesis_info_opt_get", _wrap_synthesis_info_opt_get, METH_O, NULL},
	 { "synthesis_info_dict_set", _wrap_synthesis_info_dict_set, METH_VARARGS, NULL},
	 { "synthesis_info_dict_get", _wrap_synthesis_info_dict_get, METH_O, NULL},
	 { "delete_synthesis_info", _wrap_delete_synthesis_info, METH_O, NULL},
	 { "synthesis_info_swigregister", synthesis_info_swigregister, METH_O, NULL},
	 { "synthesis_info_swiginit", synthesis_info_swiginit, METH_VARARGS, NULL},
	 { "__lshift__", _wrap___lshift__, METH_VARARGS, NULL},
	 { "ltl_to_game", _wrap_ltl_to_game, METH_VARARGS, NULL},
	 { "solved_game_to_mealy", _wrap_solved_game_to_mealy, METH_VARARGS, NULL},
	 { "solved_game_to_separated_mealy", _wrap_solved_game_to_separated_mealy, METH_VARARGS, NULL},
	 { "solved_game_to_split_mealy", _wrap_solved_game_to_split_mealy, METH_VARARGS, NULL},
	 { "mealy_like_success_set", _wrap_mealy_like_success_set, METH_VARARGS, NULL},
	 { "mealy_like_success_get", _wrap_mealy_like_success_get, METH_O, NULL},
	 { "mealy_like_mealy_like_set", _wrap_mealy_like_mealy_like_set, METH_VARARGS, NULL},
	 { "mealy_like_mealy_like_get", _wrap_mealy_like_mealy_like_get, METH_O, NULL},
	 { "mealy_like_glob_cond_set", _wrap_mealy_like_glob_cond_set, METH_VARARGS, NULL},
	 { "mealy_like_glob_cond_get", _wrap_mealy_like_glob_cond_get, METH_O, NULL},
	 { "delete_mealy_like", _wrap_delete_mealy_like, METH_O, NULL},
	 { "mealy_like_swigregister", mealy_like_swigregister, METH_O, NULL},
	 { "split_independant_formulas", _wrap_split_independant_formulas, METH_VARARGS, NULL},
	 { "try_create_direct_strategy", _wrap_try_create_direct_strategy, METH_VARARGS, NULL},
	 { "solve_game", _wrap_solve_game, METH_VARARGS, NULL},
	 { "game_relabeling_map_env_map_set", _wrap_game_relabeling_map_env_map_set, METH_VARARGS, NULL},
	 { "game_relabeling_map_env_map_get", _wrap_game_relabeling_map_env_map_get, METH_O, NULL},
	 { "game_relabeling_map_player_map_set", _wrap_game_relabeling_map_player_map_set, METH_VARARGS, NULL},
	 { "game_relabeling_map_player_map_get", _wrap_game_relabeling_map_player_map_get, METH_O, NULL},
	 { "new_game_relabeling_map", _wrap_new_game_relabeling_map, METH_NOARGS, NULL},
	 { "delete_game_relabeling_map", _wrap_delete_game_relabeling_map, METH_O, NULL},
	 { "game_relabeling_map_swigregister", game_relabeling_map_swigregister, METH_O, NULL},
	 { "game_relabeling_map_swiginit", game_relabeling_map_swiginit, METH_VARARGS, NULL},
	 { "partitioned_game_relabel_here", _wrap_partitioned_game_relabel_here, METH_VARARGS, NULL},
	 { "relabel_game_here", _wrap_relabel_game_here, METH_VARARGS, NULL},
	 { "new_translator", _wrap_new_translator, METH_VARARGS, NULL},
	 { "delete_translator", _wrap_delete_translator, METH_O, NULL},
	 { "translator_set_type", _wrap_translator_set_type, METH_VARARGS, NULL},
	 { "translator_set_pref", _wrap_translator_set_pref, METH_VARARGS, NULL},
	 { "translator_set_level", _wrap_translator_set_level, METH_VARARGS, NULL},
	 { "translator_run", _wrap_translator_run, METH_VARARGS, NULL},
	 { "translator_clear_caches", _wrap_translator_clear_caches, METH_O, NULL},
	 { "translator_swigregister", translator_swigregister, METH_O, NULL},
	 { "translator_swiginit", translator_swiginit, METH_VARARGS, NULL},
	 { "to_weak_alternating", _wrap_to_weak_alternating, METH_VARARGS, NULL},
	 { "print_hoa", _wrap_print_hoa, METH_VARARGS, NULL},
	 { "get_aliases", _wrap_get_aliases, METH_O, NULL},
	 { "set_aliases", _wrap_set_aliases, METH_VARARGS, NULL},
	 { "new_hoa_alias_formater", _wrap_new_hoa_alias_formater, METH_VARARGS, NULL},
	 { "hoa_alias_formater_encode_label", _wrap_hoa_alias_formater_encode_label, METH_VARARGS, NULL},
	 { "hoa_alias_formater_aliases", _wrap_hoa_alias_formater_aliases, METH_O, NULL},
	 { "delete_hoa_alias_formater", _wrap_delete_hoa_alias_formater, METH_O, NULL},
	 { "hoa_alias_formater_swigregister", hoa_alias_formater_swigregister, METH_O, NULL},
	 { "hoa_alias_formater_swiginit", hoa_alias_formater_swiginit, METH_VARARGS, NULL},
	 { "dtwa_sat_synthetize", _wrap_dtwa_sat_synthetize, METH_VARARGS, NULL},
	 { "dtwa_sat_minimize", _wrap_dtwa_sat_minimize, METH_VARARGS, NULL},
	 { "dtwa_sat_minimize_dichotomy", _wrap_dtwa_sat_minimize_dichotomy, METH_VARARGS, NULL},
	 { "dtwa_sat_minimize_incr", _wrap_dtwa_sat_minimize_incr, METH_VARARGS, NULL},
	 { "dtwa_sat_minimize_assume", _wrap_dtwa_sat_minimize_assume, METH_VARARGS, NULL},
	 { "sat_minimize", _wrap_sat_minimize, METH_VARARGS, NULL},
	 { "relabel_here", _wrap_relabel_here, METH_VARARGS, NULL},
	 { "partitioned_relabel_here", _wrap_partitioned_relabel_here, METH_VARARGS, NULL},
	 { "new_twa_word", _wrap_new_twa_word, METH_VARARGS, NULL},
	 { "delete_twa_word", _wrap_delete_twa_word, METH_O, NULL},
	 { "twa_word_simplify", _wrap_twa_word_simplify, METH_O, NULL},
	 { "twa_word_use_all_aps", _wrap_twa_word_use_all_aps, METH_VARARGS, NULL},
	 { "twa_word_prefix_set", _wrap_twa_word_prefix_set, METH_VARARGS, NULL},
	 { "twa_word_prefix_get", _wrap_twa_word_prefix_get, METH_O, NULL},
	 { "twa_word_cycle_set", _wrap_twa_word_cycle_set, METH_VARARGS, NULL},
	 { "twa_word_cycle_get", _wrap_twa_word_cycle_get, METH_O, NULL},
	 { "twa_word_get_dict", _wrap_twa_word_get_dict, METH_O, NULL},
	 { "twa_word_as_automaton", _wrap_twa_word_as_automaton, METH_O, NULL},
	 { "twa_word___str__", _wrap_twa_word___str__, METH_O, NULL},
	 { "twa_word_swigregister", twa_word_swigregister, METH_O, NULL},
	 { "twa_word_swiginit", twa_word_swiginit, METH_VARARGS, NULL},
	 { "make_twa_word", _wrap_make_twa_word, METH_VARARGS, NULL},
	 { "parse_word", _wrap_parse_word, METH_VARARGS, NULL},
	 { "list_bdd_iterator", _wrap_list_bdd_iterator, METH_O, NULL},
	 { "list_bdd___nonzero__", _wrap_list_bdd___nonzero__, METH_O, NULL},
	 { "list_bdd___bool__", _wrap_list_bdd___bool__, METH_O, NULL},
	 { "list_bdd___len__", _wrap_list_bdd___len__, METH_O, NULL},
	 { "list_bdd___getslice__", _wrap_list_bdd___getslice__, METH_VARARGS, NULL},
	 { "list_bdd___setslice__", _wrap_list_bdd___setslice__, METH_VARARGS, NULL},
	 { "list_bdd___delslice__", _wrap_list_bdd___delslice__, METH_VARARGS, NULL},
	 { "list_bdd___delitem__", _wrap_list_bdd___delitem__, METH_VARARGS, NULL},
	 { "list_bdd___getitem__", _wrap_list_bdd___getitem__, METH_VARARGS, NULL},
	 { "list_bdd___setitem__", _wrap_list_bdd___setitem__, METH_VARARGS, NULL},
	 { "list_bdd_pop", _wrap_list_bdd_pop, METH_O, NULL},
	 { "list_bdd_append", _wrap_list_bdd_append, METH_VARARGS, NULL},
	 { "list_bdd_empty", _wrap_list_bdd_empty, METH_O, NULL},
	 { "list_bdd_size", _wrap_list_bdd_size, METH_O, NULL},
	 { "list_bdd_swap", _wrap_list_bdd_swap, METH_VARARGS, NULL},
	 { "list_bdd_begin", _wrap_list_bdd_begin, METH_O, NULL},
	 { "list_bdd_end", _wrap_list_bdd_end, METH_O, NULL},
	 { "list_bdd_rbegin", _wrap_list_bdd_rbegin, METH_O, NULL},
	 { "list_bdd_rend", _wrap_list_bdd_rend, METH_O, NULL},
	 { "list_bdd_clear", _wrap_list_bdd_clear, METH_O, NULL},
	 { "list_bdd_get_allocator", _wrap_list_bdd_get_allocator, METH_O, NULL},
	 { "list_bdd_pop_back", _wrap_list_bdd_pop_back, METH_O, NULL},
	 { "list_bdd_erase", _wrap_list_bdd_erase, METH_VARARGS, NULL},
	 { "new_list_bdd", _wrap_new_list_bdd, METH_VARARGS, NULL},
	 { "list_bdd_push_back", _wrap_list_bdd_push_back, METH_VARARGS, NULL},
	 { "list_bdd_front", _wrap_list_bdd_front, METH_O, NULL},
	 { "list_bdd_back", _wrap_list_bdd_back, METH_O, NULL},
	 { "list_bdd_assign", _wrap_list_bdd_assign, METH_VARARGS, NULL},
	 { "list_bdd_resize", _wrap_list_bdd_resize, METH_VARARGS, NULL},
	 { "list_bdd_insert", _wrap_list_bdd_insert, METH_VARARGS, NULL},
	 { "list_bdd_pop_front", _wrap_list_bdd_pop_front, METH_O, NULL},
	 { "list_bdd_push_front", _wrap_list_bdd_push_front, METH_VARARGS, NULL},
	 { "list_bdd_reverse", _wrap_list_bdd_reverse, METH_O, NULL},
	 { "delete_list_bdd", _wrap_delete_list_bdd, METH_O, NULL},
	 { "list_bdd_swigregister", list_bdd_swigregister, METH_O, NULL},
	 { "list_bdd_swiginit", list_bdd_swiginit, METH_VARARGS, NULL},
	 { "new_isomorphism_checker", _wrap_new_isomorphism_checker, METH_O, NULL},
	 { "isomorphism_checker_is_isomorphic", _wrap_isomorphism_checker_is_isomorphic, METH_VARARGS, NULL},
	 { "isomorphism_checker_are_isomorphic", _wrap_isomorphism_checker_are_isomorphic, METH_VARARGS, NULL},
	 { "delete_isomorphism_checker", _wrap_delete_isomorphism_checker, METH_O, NULL},
	 { "isomorphism_checker_swigregister", isomorphism_checker_swigregister, METH_O, NULL},
	 { "isomorphism_checker_swiginit", isomorphism_checker_swiginit, METH_VARARGS, NULL},
	 { "to_parity_data_nb_states_created_set", _wrap_to_parity_data_nb_states_created_set, METH_VARARGS, NULL},
	 { "to_parity_data_nb_states_created_get", _wrap_to_parity_data_nb_states_created_get, METH_O, NULL},
	 { "to_parity_data_nb_edges_created_set", _wrap_to_parity_data_nb_edges_created_set, METH_VARARGS, NULL},
	 { "to_parity_data_nb_edges_created_get", _wrap_to_parity_data_nb_edges_created_get, METH_O, NULL},
	 { "to_parity_data_algorithms_used_set", _wrap_to_parity_data_algorithms_used_set, METH_VARARGS, NULL},
	 { "to_parity_data_algorithms_used_get", _wrap_to_parity_data_algorithms_used_get, METH_O, NULL},
	 { "new_to_parity_data", _wrap_new_to_parity_data, METH_NOARGS, NULL},
	 { "delete_to_parity_data", _wrap_delete_to_parity_data, METH_O, NULL},
	 { "to_parity_data_swigregister", to_parity_data_swigregister, METH_O, NULL},
	 { "to_parity_data_swiginit", to_parity_data_swiginit, METH_VARARGS, NULL},
	 { "to_parity_options_search_ex_set", _wrap_to_parity_options_search_ex_set, METH_VARARGS, NULL},
	 { "to_parity_options_search_ex_get", _wrap_to_parity_options_search_ex_get, METH_O, NULL},
	 { "to_parity_options_use_last_set", _wrap_to_parity_options_use_last_set, METH_VARARGS, NULL},
	 { "to_parity_options_use_last_get", _wrap_to_parity_options_use_last_get, METH_O, NULL},
	 { "to_parity_options_use_last_post_process_set", _wrap_to_parity_options_use_last_post_process_set, METH_VARARGS, NULL},
	 { "to_parity_options_use_last_post_process_get", _wrap_to_parity_options_use_last_post_process_get, METH_O, NULL},
	 { "to_parity_options_force_order_set", _wrap_to_parity_options_force_order_set, METH_VARARGS, NULL},
	 { "to_parity_options_force_order_get", _wrap_to_parity_options_force_order_get, METH_O, NULL},
	 { "to_parity_options_partial_degen_set", _wrap_to_parity_options_partial_degen_set, METH_VARARGS, NULL},
	 { "to_parity_options_partial_degen_get", _wrap_to_parity_options_partial_degen_get, METH_O, NULL},
	 { "to_parity_options_acc_clean_set", _wrap_to_parity_options_acc_clean_set, METH_VARARGS, NULL},
	 { "to_parity_options_acc_clean_get", _wrap_to_parity_options_acc_clean_get, METH_O, NULL},
	 { "to_parity_options_parity_equiv_set", _wrap_to_parity_options_parity_equiv_set, METH_VARARGS, NULL},
	 { "to_parity_options_parity_equiv_get", _wrap_to_parity_options_parity_equiv_get, METH_O, NULL},
	 { "to_parity_options_car_set", _wrap_to_parity_options_car_set, METH_VARARGS, NULL},
	 { "to_parity_options_car_get", _wrap_to_parity_options_car_get, METH_O, NULL},
	 { "to_parity_options_tar_set", _wrap_to_parity_options_tar_set, METH_VARARGS, NULL},
	 { "to_parity_options_tar_get", _wrap_to_parity_options_tar_get, METH_O, NULL},
	 { "to_parity_options_iar_set", _wrap_to_parity_options_iar_set, METH_VARARGS, NULL},
	 { "to_parity_options_iar_get", _wrap_to_parity_options_iar_get, METH_O, NULL},
	 { "to_parity_options_lar_dfs_set", _wrap_to_parity_options_lar_dfs_set, METH_VARARGS, NULL},
	 { "to_parity_options_lar_dfs_get", _wrap_to_parity_options_lar_dfs_get, METH_O, NULL},
	 { "to_parity_options_bscc_set", _wrap_to_parity_options_bscc_set, METH_VARARGS, NULL},
	 { "to_parity_options_bscc_get", _wrap_to_parity_options_bscc_get, METH_O, NULL},
	 { "to_parity_options_parity_prefix_set", _wrap_to_parity_options_parity_prefix_set, METH_VARARGS, NULL},
	 { "to_parity_options_parity_prefix_get", _wrap_to_parity_options_parity_prefix_get, METH_O, NULL},
	 { "to_parity_options_parity_prefix_general_set", _wrap_to_parity_options_parity_prefix_general_set, METH_VARARGS, NULL},
	 { "to_parity_options_parity_prefix_general_get", _wrap_to_parity_options_parity_prefix_general_get, METH_O, NULL},
	 { "to_parity_options_generic_emptiness_set", _wrap_to_parity_options_generic_emptiness_set, METH_VARARGS, NULL},
	 { "to_parity_options_generic_emptiness_get", _wrap_to_parity_options_generic_emptiness_get, METH_O, NULL},
	 { "to_parity_options_rabin_to_buchi_set", _wrap_to_parity_options_rabin_to_buchi_set, METH_VARARGS, NULL},
	 { "to_parity_options_rabin_to_buchi_get", _wrap_to_parity_options_rabin_to_buchi_get, METH_O, NULL},
	 { "to_parity_options_buchi_type_to_buchi_set", _wrap_to_parity_options_buchi_type_to_buchi_set, METH_VARARGS, NULL},
	 { "to_parity_options_buchi_type_to_buchi_get", _wrap_to_parity_options_buchi_type_to_buchi_get, METH_O, NULL},
	 { "to_parity_options_parity_type_to_parity_set", _wrap_to_parity_options_parity_type_to_parity_set, METH_VARARGS, NULL},
	 { "to_parity_options_parity_type_to_parity_get", _wrap_to_parity_options_parity_type_to_parity_get, METH_O, NULL},
	 { "to_parity_options_reduce_col_deg_set", _wrap_to_parity_options_reduce_col_deg_set, METH_VARARGS, NULL},
	 { "to_parity_options_reduce_col_deg_get", _wrap_to_parity_options_reduce_col_deg_get, METH_O, NULL},
	 { "to_parity_options_propagate_col_set", _wrap_to_parity_options_propagate_col_set, METH_VARARGS, NULL},
	 { "to_parity_options_propagate_col_get", _wrap_to_parity_options_propagate_col_get, METH_O, NULL},
	 { "to_parity_options_use_generalized_rabin_set", _wrap_to_parity_options_use_generalized_rabin_set, METH_VARARGS, NULL},
	 { "to_parity_options_use_generalized_rabin_get", _wrap_to_parity_options_use_generalized_rabin_get, METH_O, NULL},
	 { "to_parity_options_pretty_print_set", _wrap_to_parity_options_pretty_print_set, METH_VARARGS, NULL},
	 { "to_parity_options_pretty_print_get", _wrap_to_parity_options_pretty_print_get, METH_O, NULL},
	 { "to_parity_options_datas_set", _wrap_to_parity_options_datas_set, METH_VARARGS, NULL},
	 { "to_parity_options_datas_get", _wrap_to_parity_options_datas_get, METH_O, NULL},
	 { "new_to_parity_options", _wrap_new_to_parity_options, METH_NOARGS, NULL},
	 { "delete_to_parity_options", _wrap_delete_to_parity_options, METH_O, NULL},
	 { "to_parity_options_swigregister", to_parity_options_swigregister, METH_O, NULL},
	 { "to_parity_options_swiginit", to_parity_options_swiginit, METH_VARARGS, NULL},
	 { "to_parity", _wrap_to_parity, METH_VARARGS, NULL},
	 { "to_parity_old", _wrap_to_parity_old, METH_VARARGS, NULL},
	 { "iar", _wrap_iar, METH_VARARGS, NULL},
	 { "iar_maybe", _wrap_iar_maybe, METH_VARARGS, NULL},
	 { "parity_type_to_parity", _wrap_parity_type_to_parity, METH_O, NULL},
	 { "buchi_type_to_buchi", _wrap_buchi_type_to_buchi, METH_O, NULL},
	 { "co_buchi_type_to_co_buchi", _wrap_co_buchi_type_to_co_buchi, METH_O, NULL},
	 { "new_zielonka_tree", _wrap_new_zielonka_tree, METH_VARARGS, NULL},
	 { "zielonka_tree_num_branches", _wrap_zielonka_tree_num_branches, METH_O, NULL},
	 { "zielonka_tree_first_branch", _wrap_zielonka_tree_first_branch, METH_O, NULL},
	 { "zielonka_tree_step", _wrap_zielonka_tree_step, METH_VARARGS, NULL},
	 { "zielonka_tree_is_even", _wrap_zielonka_tree_is_even, METH_O, NULL},
	 { "zielonka_tree_has_rabin_shape", _wrap_zielonka_tree_has_rabin_shape, METH_O, NULL},
	 { "zielonka_tree_has_streett_shape", _wrap_zielonka_tree_has_streett_shape, METH_O, NULL},
	 { "zielonka_tree_has_parity_shape", _wrap_zielonka_tree_has_parity_shape, METH_O, NULL},
	 { "zielonka_tree_dot", _wrap_zielonka_tree_dot, METH_VARARGS, NULL},
	 { "zielonka_tree_nodes__set", _wrap_zielonka_tree_nodes__set, METH_VARARGS, NULL},
	 { "zielonka_tree_nodes__get", _wrap_zielonka_tree_nodes__get, METH_O, NULL},
	 { "delete_zielonka_tree", _wrap_delete_zielonka_tree, METH_O, NULL},
	 { "zielonka_tree_swigregister", zielonka_tree_swigregister, METH_O, NULL},
	 { "zielonka_tree_swiginit", zielonka_tree_swiginit, METH_VARARGS, NULL},
	 { "zielonka_tree_transform", _wrap_zielonka_tree_transform, METH_O, NULL},
	 { "new_acd", _wrap_new_acd, METH_VARARGS, NULL},
	 { "delete_acd", _wrap_delete_acd, METH_O, NULL},
	 { "acd_step", _wrap_acd_step, METH_VARARGS, NULL},
	 { "acd_state_step", _wrap_acd_state_step, METH_VARARGS, NULL},
	 { "acd_edges_of_node", _wrap_acd_edges_of_node, METH_VARARGS, NULL},
	 { "acd_node_count", _wrap_acd_node_count, METH_O, NULL},
	 { "acd_node_acceptance", _wrap_acd_node_acceptance, METH_VARARGS, NULL},
	 { "acd_node_level", _wrap_acd_node_level, METH_VARARGS, NULL},
	 { "acd_node_colors", _wrap_acd_node_colors, METH_VARARGS, NULL},
	 { "acd_is_even", _wrap_acd_is_even, METH_VARARGS, NULL},
	 { "acd_first_branch", _wrap_acd_first_branch, METH_VARARGS, NULL},
	 { "acd_scc_max_level", _wrap_acd_scc_max_level, METH_VARARGS, NULL},
	 { "acd_has_rabin_shape", _wrap_acd_has_rabin_shape, METH_O, NULL},
	 { "acd_has_streett_shape", _wrap_acd_has_streett_shape, METH_O, NULL},
	 { "acd_has_parity_shape", _wrap_acd_has_parity_shape, METH_O, NULL},
	 { "acd_get_aut", _wrap_acd_get_aut, METH_O, NULL},
	 { "acd_dot", _wrap_acd_dot, METH_VARARGS, NULL},
	 { "acd_swigregister", acd_swigregister, METH_O, NULL},
	 { "acd_swiginit", acd_swiginit, METH_VARARGS, NULL},
	 { "acd_transform", _wrap_acd_transform, METH_VARARGS, NULL},
	 { "acd_transform_sbacc", _wrap_acd_transform_sbacc, METH_VARARGS, NULL},
	 { "dtwa_complement", _wrap_dtwa_complement, METH_O, NULL},
	 { "complement_semidet", _wrap_complement_semidet, METH_VARARGS, NULL},
	 { "complement", _wrap_complement, METH_VARARGS, NULL},
	 { "delete_fair_kripke_succ_iterator", _wrap_delete_fair_kripke_succ_iterator, METH_O, NULL},
	 { "fair_kripke_succ_iterator_swigregister", fair_kripke_succ_iterator_swigregister, METH_O, NULL},
	 { "fair_kripke_state_condition", _wrap_fair_kripke_state_condition, METH_VARARGS, NULL},
	 { "fair_kripke_state_acceptance_mark", _wrap_fair_kripke_state_acceptance_mark, METH_VARARGS, NULL},
	 { "delete_fair_kripke", _wrap_delete_fair_kripke, METH_O, NULL},
	 { "fair_kripke_swigregister", fair_kripke_swigregister, METH_O, NULL},
	 { "kripke_succ_iterator_recycle", _wrap_kripke_succ_iterator_recycle, METH_VARARGS, NULL},
	 { "delete_kripke_succ_iterator", _wrap_delete_kripke_succ_iterator, METH_O, NULL},
	 { "kripke_succ_iterator_swigregister", kripke_succ_iterator_swigregister, METH_O, NULL},
	 { "delete_kripke", _wrap_delete_kripke, METH_O, NULL},
	 { "kripke_swigregister", kripke_swigregister, METH_O, NULL},
	 { "new_kripke_graph_state", _wrap_new_kripke_graph_state, METH_VARARGS, NULL},
	 { "delete_kripke_graph_state", _wrap_delete_kripke_graph_state, METH_O, NULL},
	 { "kripke_graph_state_clone", _wrap_kripke_graph_state_clone, METH_O, NULL},
	 { "kripke_graph_state_cond", _wrap_kripke_graph_state_cond, METH_VARARGS, NULL},
	 { "kripke_graph_state_swigregister", kripke_graph_state_swigregister, METH_O, NULL},
	 { "kripke_graph_state_swiginit", kripke_graph_state_swiginit, METH_VARARGS, NULL},
	 { "new_kripke_graph", _wrap_new_kripke_graph, METH_O, NULL},
	 { "delete_kripke_graph", _wrap_delete_kripke_graph, METH_O, NULL},
	 { "kripke_graph_num_states", _wrap_kripke_graph_num_states, METH_O, NULL},
	 { "kripke_graph_num_edges", _wrap_kripke_graph_num_edges, METH_O, NULL},
	 { "kripke_graph_set_init_state", _wrap_kripke_graph_set_init_state, METH_VARARGS, NULL},
	 { "kripke_graph_get_init_state_number", _wrap_kripke_graph_get_init_state_number, METH_O, NULL},
	 { "kripke_graph_get_init_state", _wrap_kripke_graph_get_init_state, METH_O, NULL},
	 { "kripke_graph_succ_iter", _wrap_kripke_graph_succ_iter, METH_VARARGS, NULL},
	 { "kripke_graph_state_number", _wrap_kripke_graph_state_number, METH_VARARGS, NULL},
	 { "kripke_graph_state_from_number", _wrap_kripke_graph_state_from_number, METH_VARARGS, NULL},
	 { "kripke_graph_format_state", _wrap_kripke_graph_format_state, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage", _wrap_kripke_graph_edge_storage, METH_VARARGS, NULL},
	 { "kripke_graph_new_state", _wrap_kripke_graph_new_state, METH_VARARGS, NULL},
	 { "kripke_graph_new_states", _wrap_kripke_graph_new_states, METH_VARARGS, NULL},
	 { "kripke_graph_new_edge", _wrap_kripke_graph_new_edge, METH_VARARGS, NULL},
	 { "kripke_graph_states", _wrap_kripke_graph_states, METH_O, NULL},
	 { "kripke_graph_edges", _wrap_kripke_graph_edges, METH_O, NULL},
	 { "kripke_graph_out", _wrap_kripke_graph_out, METH_VARARGS, NULL},
	 { "kripke_graph_swigregister", kripke_graph_swigregister, METH_O, NULL},
	 { "kripke_graph_swiginit", kripke_graph_swiginit, METH_VARARGS, NULL},
	 { "make_kripke_graph", _wrap_make_kripke_graph, METH_O, NULL},
	 { "new_kripke_graph_state_out", _wrap_new_kripke_graph_state_out, METH_VARARGS, NULL},
	 { "kripke_graph_state_out_begin", _wrap_kripke_graph_state_out_begin, METH_O, NULL},
	 { "kripke_graph_state_out_end", _wrap_kripke_graph_state_out_end, METH_O, NULL},
	 { "kripke_graph_state_out_recycle", _wrap_kripke_graph_state_out_recycle, METH_VARARGS, NULL},
	 { "kripke_graph_state_out___iter__", _wrap_kripke_graph_state_out___iter__, METH_O, NULL},
	 { "delete_kripke_graph_state_out", _wrap_delete_kripke_graph_state_out, METH_O, NULL},
	 { "kripke_graph_state_out_swigregister", kripke_graph_state_out_swigregister, METH_O, NULL},
	 { "kripke_graph_state_out_swiginit", kripke_graph_state_out_swiginit, METH_VARARGS, NULL},
	 { "new_kripke_graph_all_trans", _wrap_new_kripke_graph_all_trans, METH_O, NULL},
	 { "kripke_graph_all_trans_begin", _wrap_kripke_graph_all_trans_begin, METH_O, NULL},
	 { "kripke_graph_all_trans_end", _wrap_kripke_graph_all_trans_end, METH_O, NULL},
	 { "kripke_graph_all_trans___iter__", _wrap_kripke_graph_all_trans___iter__, METH_O, NULL},
	 { "delete_kripke_graph_all_trans", _wrap_delete_kripke_graph_all_trans, METH_O, NULL},
	 { "kripke_graph_all_trans_swigregister", kripke_graph_all_trans_swigregister, METH_O, NULL},
	 { "kripke_graph_all_trans_swiginit", kripke_graph_all_trans_swiginit, METH_VARARGS, NULL},
	 { "kripke_graph_edge_boxed_data_data", _wrap_kripke_graph_edge_boxed_data_data, METH_VARARGS, NULL},
	 { "new_kripke_graph_edge_boxed_data", _wrap_new_kripke_graph_edge_boxed_data, METH_NOARGS, NULL},
	 { "delete_kripke_graph_edge_boxed_data", _wrap_delete_kripke_graph_edge_boxed_data, METH_O, NULL},
	 { "kripke_graph_edge_boxed_data_swigregister", kripke_graph_edge_boxed_data_swigregister, METH_O, NULL},
	 { "kripke_graph_edge_boxed_data_swiginit", kripke_graph_edge_boxed_data_swiginit, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage_dst_set", _wrap_kripke_graph_edge_storage_dst_set, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage_dst_get", _wrap_kripke_graph_edge_storage_dst_get, METH_O, NULL},
	 { "kripke_graph_edge_storage_next_succ_set", _wrap_kripke_graph_edge_storage_next_succ_set, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage_next_succ_get", _wrap_kripke_graph_edge_storage_next_succ_get, METH_O, NULL},
	 { "kripke_graph_edge_storage_src_set", _wrap_kripke_graph_edge_storage_src_set, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage_src_get", _wrap_kripke_graph_edge_storage_src_get, METH_O, NULL},
	 { "new_kripke_graph_edge_storage", _wrap_new_kripke_graph_edge_storage, METH_NOARGS, NULL},
	 { "kripke_graph_edge_storage___lt__", _wrap_kripke_graph_edge_storage___lt__, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage___eq__", _wrap_kripke_graph_edge_storage___eq__, METH_VARARGS, NULL},
	 { "delete_kripke_graph_edge_storage", _wrap_delete_kripke_graph_edge_storage, METH_O, NULL},
	 { "kripke_graph_edge_storage_swigregister", kripke_graph_edge_storage_swigregister, METH_O, NULL},
	 { "kripke_graph_edge_storage_swiginit", kripke_graph_edge_storage_swiginit, METH_VARARGS, NULL},
	 { "new_kripke_graph_state_boxed_data", _wrap_new_kripke_graph_state_boxed_data, METH_NOARGS, NULL},
	 { "kripke_graph_state_boxed_data_data", _wrap_kripke_graph_state_boxed_data_data, METH_VARARGS, NULL},
	 { "delete_kripke_graph_state_boxed_data", _wrap_delete_kripke_graph_state_boxed_data, METH_O, NULL},
	 { "kripke_graph_state_boxed_data_swigregister", kripke_graph_state_boxed_data_swigregister, METH_O, NULL},
	 { "kripke_graph_state_boxed_data_swiginit", kripke_graph_state_boxed_data_swiginit, METH_VARARGS, NULL},
	 { "kripke_graph_state_storage_succ_set", _wrap_kripke_graph_state_storage_succ_set, METH_VARARGS, NULL},
	 { "kripke_graph_state_storage_succ_get", _wrap_kripke_graph_state_storage_succ_get, METH_O, NULL},
	 { "kripke_graph_state_storage_succ_tail_set", _wrap_kripke_graph_state_storage_succ_tail_set, METH_VARARGS, NULL},
	 { "kripke_graph_state_storage_succ_tail_get", _wrap_kripke_graph_state_storage_succ_tail_get, METH_O, NULL},
	 { "new_kripke_graph_state_storage", _wrap_new_kripke_graph_state_storage, METH_NOARGS, NULL},
	 { "delete_kripke_graph_state_storage", _wrap_delete_kripke_graph_state_storage, METH_O, NULL},
	 { "kripke_graph_state_storage_swigregister", kripke_graph_state_storage_swigregister, METH_O, NULL},
	 { "kripke_graph_state_storage_swiginit", kripke_graph_state_storage_swiginit, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_iterator", _wrap_kripke_graph_state_vector_iterator, METH_O, NULL},
	 { "kripke_graph_state_vector___nonzero__", _wrap_kripke_graph_state_vector___nonzero__, METH_O, NULL},
	 { "kripke_graph_state_vector___bool__", _wrap_kripke_graph_state_vector___bool__, METH_O, NULL},
	 { "kripke_graph_state_vector___len__", _wrap_kripke_graph_state_vector___len__, METH_O, NULL},
	 { "kripke_graph_state_vector___getslice__", _wrap_kripke_graph_state_vector___getslice__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector___setslice__", _wrap_kripke_graph_state_vector___setslice__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector___delslice__", _wrap_kripke_graph_state_vector___delslice__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector___delitem__", _wrap_kripke_graph_state_vector___delitem__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector___getitem__", _wrap_kripke_graph_state_vector___getitem__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector___setitem__", _wrap_kripke_graph_state_vector___setitem__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_pop", _wrap_kripke_graph_state_vector_pop, METH_O, NULL},
	 { "kripke_graph_state_vector_append", _wrap_kripke_graph_state_vector_append, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_empty", _wrap_kripke_graph_state_vector_empty, METH_O, NULL},
	 { "kripke_graph_state_vector_size", _wrap_kripke_graph_state_vector_size, METH_O, NULL},
	 { "kripke_graph_state_vector_swap", _wrap_kripke_graph_state_vector_swap, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_begin", _wrap_kripke_graph_state_vector_begin, METH_O, NULL},
	 { "kripke_graph_state_vector_end", _wrap_kripke_graph_state_vector_end, METH_O, NULL},
	 { "kripke_graph_state_vector_rbegin", _wrap_kripke_graph_state_vector_rbegin, METH_O, NULL},
	 { "kripke_graph_state_vector_rend", _wrap_kripke_graph_state_vector_rend, METH_O, NULL},
	 { "kripke_graph_state_vector_clear", _wrap_kripke_graph_state_vector_clear, METH_O, NULL},
	 { "kripke_graph_state_vector_get_allocator", _wrap_kripke_graph_state_vector_get_allocator, METH_O, NULL},
	 { "kripke_graph_state_vector_pop_back", _wrap_kripke_graph_state_vector_pop_back, METH_O, NULL},
	 { "kripke_graph_state_vector_erase", _wrap_kripke_graph_state_vector_erase, METH_VARARGS, NULL},
	 { "new_kripke_graph_state_vector", _wrap_new_kripke_graph_state_vector, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_push_back", _wrap_kripke_graph_state_vector_push_back, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_front", _wrap_kripke_graph_state_vector_front, METH_O, NULL},
	 { "kripke_graph_state_vector_back", _wrap_kripke_graph_state_vector_back, METH_O, NULL},
	 { "kripke_graph_state_vector_assign", _wrap_kripke_graph_state_vector_assign, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_resize", _wrap_kripke_graph_state_vector_resize, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_insert", _wrap_kripke_graph_state_vector_insert, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_reserve", _wrap_kripke_graph_state_vector_reserve, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_capacity", _wrap_kripke_graph_state_vector_capacity, METH_O, NULL},
	 { "delete_kripke_graph_state_vector", _wrap_delete_kripke_graph_state_vector, METH_O, NULL},
	 { "kripke_graph_state_vector_swigregister", kripke_graph_state_vector_swigregister, METH_O, NULL},
	 { "kripke_graph_state_vector_swiginit", kripke_graph_state_vector_swiginit, METH_VARARGS, NULL},
	 { "parse_aut_error_list___nonzero__", _wrap_parse_aut_error_list___nonzero__, METH_O, NULL},
	 { "parse_aut_error_list___bool__", _wrap_parse_aut_error_list___bool__, METH_O, NULL},
	 { "new_parse_aut_error_list", _wrap_new_parse_aut_error_list, METH_NOARGS, NULL},
	 { "delete_parse_aut_error_list", _wrap_delete_parse_aut_error_list, METH_O, NULL},
	 { "parse_aut_error_list_swigregister", parse_aut_error_list_swigregister, METH_O, NULL},
	 { "parse_aut_error_list_swiginit", parse_aut_error_list_swiginit, METH_VARARGS, NULL},
	 { "parsed_aut_aut_set", _wrap_parsed_aut_aut_set, METH_VARARGS, NULL},
	 { "parsed_aut_aut_get", _wrap_parsed_aut_aut_get, METH_O, NULL},
	 { "parsed_aut_ks_set", _wrap_parsed_aut_ks_set, METH_VARARGS, NULL},
	 { "parsed_aut_ks_get", _wrap_parsed_aut_ks_get, METH_O, NULL},
	 { "parsed_aut_aborted_set", _wrap_parsed_aut_aborted_set, METH_VARARGS, NULL},
	 { "parsed_aut_aborted_get", _wrap_parsed_aut_aborted_get, METH_O, NULL},
	 { "parsed_aut_loc_set", _wrap_parsed_aut_loc_set, METH_VARARGS, NULL},
	 { "parsed_aut_loc_get", _wrap_parsed_aut_loc_get, METH_O, NULL},
	 { "parsed_aut_type_set", _wrap_parsed_aut_type_set, METH_VARARGS, NULL},
	 { "parsed_aut_type_get", _wrap_parsed_aut_type_get, METH_O, NULL},
	 { "parsed_aut_filename_set", _wrap_parsed_aut_filename_set, METH_VARARGS, NULL},
	 { "parsed_aut_filename_get", _wrap_parsed_aut_filename_get, METH_O, NULL},
	 { "parsed_aut_errors_set", _wrap_parsed_aut_errors_set, METH_VARARGS, NULL},
	 { "parsed_aut_errors_get", _wrap_parsed_aut_errors_get, METH_O, NULL},
	 { "new_parsed_aut", _wrap_new_parsed_aut, METH_O, NULL},
	 { "parsed_aut_format_errors", _wrap_parsed_aut_format_errors, METH_VARARGS, NULL},
	 { "delete_parsed_aut", _wrap_delete_parsed_aut, METH_O, NULL},
	 { "parsed_aut_swigregister", parsed_aut_swigregister, METH_O, NULL},
	 { "parsed_aut_swiginit", parsed_aut_swiginit, METH_VARARGS, NULL},
	 { "automaton_parser_options_ignore_abort_set", _wrap_automaton_parser_options_ignore_abort_set, METH_VARARGS, NULL},
	 { "automaton_parser_options_ignore_abort_get", _wrap_automaton_parser_options_ignore_abort_get, METH_O, NULL},
	 { "automaton_parser_options_debug_set", _wrap_automaton_parser_options_debug_set, METH_VARARGS, NULL},
	 { "automaton_parser_options_debug_get", _wrap_automaton_parser_options_debug_get, METH_O, NULL},
	 { "automaton_parser_options_trust_hoa_set", _wrap_automaton_parser_options_trust_hoa_set, METH_VARARGS, NULL},
	 { "automaton_parser_options_trust_hoa_get", _wrap_automaton_parser_options_trust_hoa_get, METH_O, NULL},
	 { "automaton_parser_options_raise_errors_set", _wrap_automaton_parser_options_raise_errors_set, METH_VARARGS, NULL},
	 { "automaton_parser_options_raise_errors_get", _wrap_automaton_parser_options_raise_errors_get, METH_O, NULL},
	 { "automaton_parser_options_want_kripke_set", _wrap_automaton_parser_options_want_kripke_set, METH_VARARGS, NULL},
	 { "automaton_parser_options_want_kripke_get", _wrap_automaton_parser_options_want_kripke_get, METH_O, NULL},
	 { "new_automaton_parser_options", _wrap_new_automaton_parser_options, METH_NOARGS, NULL},
	 { "delete_automaton_parser_options", _wrap_delete_automaton_parser_options, METH_O, NULL},
	 { "automaton_parser_options_swigregister", automaton_parser_options_swigregister, METH_O, NULL},
	 { "automaton_parser_options_swiginit", automaton_parser_options_swiginit, METH_VARARGS, NULL},
	 { "new_automaton_stream_parser", _wrap_new_automaton_stream_parser, METH_VARARGS, NULL},
	 { "delete_automaton_stream_parser", _wrap_delete_automaton_stream_parser, METH_O, NULL},
	 { "automaton_stream_parser_parse", _wrap_automaton_stream_parser_parse, METH_VARARGS, NULL},
	 { "automaton_stream_parser_swigregister", automaton_stream_parser_swigregister, METH_O, NULL},
	 { "automaton_stream_parser_swiginit", automaton_stream_parser_swiginit, METH_VARARGS, NULL},
	 { "parse_aut", _wrap_parse_aut, METH_VARARGS, NULL},
	 { "delete_ta", _wrap_delete_ta, METH_O, NULL},
	 { "ta_get_initial_states_set", _wrap_ta_get_initial_states_set, METH_O, NULL},
	 { "ta_get_artificial_initial_state", _wrap_ta_get_artificial_initial_state, METH_O, NULL},
	 { "ta_succ_iter", _wrap_ta_succ_iter, METH_VARARGS, NULL},
	 { "ta_get_dict", _wrap_ta_get_dict, METH_O, NULL},
	 { "ta_format_state", _wrap_ta_format_state, METH_VARARGS, NULL},
	 { "ta_is_accepting_state", _wrap_ta_is_accepting_state, METH_VARARGS, NULL},
	 { "ta_is_livelock_accepting_state", _wrap_ta_is_livelock_accepting_state, METH_VARARGS, NULL},
	 { "ta_is_initial_state", _wrap_ta_is_initial_state, METH_VARARGS, NULL},
	 { "ta_get_state_condition", _wrap_ta_get_state_condition, METH_VARARGS, NULL},
	 { "ta_free_state", _wrap_ta_free_state, METH_VARARGS, NULL},
	 { "ta_acc", _wrap_ta_acc, METH_VARARGS, NULL},
	 { "ta_swigregister", ta_swigregister, METH_O, NULL},
	 { "delete_ta_succ_iterator", _wrap_delete_ta_succ_iterator, METH_O, NULL},
	 { "ta_succ_iterator_swigregister", ta_succ_iterator_swigregister, METH_O, NULL},
	 { "delete_tgta", _wrap_delete_tgta, METH_O, NULL},
	 { "tgta_succ_iter_by_changeset", _wrap_tgta_succ_iter_by_changeset, METH_VARARGS, NULL},
	 { "tgta_swigregister", tgta_swigregister, METH_O, NULL},
	 { "new_ta_explicit", _wrap_new_ta_explicit, METH_VARARGS, NULL},
	 { "ta_explicit_get_tgba", _wrap_ta_explicit_get_tgba, METH_O, NULL},
	 { "ta_explicit_add_state", _wrap_ta_explicit_add_state, METH_VARARGS, NULL},
	 { "ta_explicit_add_to_initial_states_set", _wrap_ta_explicit_add_to_initial_states_set, METH_VARARGS, NULL},
	 { "ta_explicit_create_transition", _wrap_ta_explicit_create_transition, METH_VARARGS, NULL},
	 { "ta_explicit_delete_stuttering_transitions", _wrap_ta_explicit_delete_stuttering_transitions, METH_O, NULL},
	 { "delete_ta_explicit", _wrap_delete_ta_explicit, METH_O, NULL},
	 { "ta_explicit_succ_iter", _wrap_ta_explicit_succ_iter, METH_VARARGS, NULL},
	 { "ta_explicit_get_dict", _wrap_ta_explicit_get_dict, METH_O, NULL},
	 { "ta_explicit_get_artificial_initial_state", _wrap_ta_explicit_get_artificial_initial_state, METH_O, NULL},
	 { "ta_explicit_set_artificial_initial_state", _wrap_ta_explicit_set_artificial_initial_state, METH_VARARGS, NULL},
	 { "ta_explicit_delete_stuttering_and_hole_successors", _wrap_ta_explicit_delete_stuttering_and_hole_successors, METH_VARARGS, NULL},
	 { "ta_explicit_get_states_set", _wrap_ta_explicit_get_states_set, METH_O, NULL},
	 { "ta_explicit_swigregister", ta_explicit_swigregister, METH_O, NULL},
	 { "ta_explicit_swiginit", ta_explicit_swiginit, METH_VARARGS, NULL},
	 { "delete_state_ta_explicit", _wrap_delete_state_ta_explicit, METH_O, NULL},
	 { "state_ta_explicit_swigregister", state_ta_explicit_swigregister, METH_O, NULL},
	 { "new_ta_explicit_succ_iterator", _wrap_new_ta_explicit_succ_iterator, METH_VARARGS, NULL},
	 { "delete_ta_explicit_succ_iterator", _wrap_delete_ta_explicit_succ_iterator, METH_O, NULL},
	 { "ta_explicit_succ_iterator_swigregister", ta_explicit_succ_iterator_swigregister, METH_O, NULL},
	 { "ta_explicit_succ_iterator_swiginit", ta_explicit_succ_iterator_swiginit, METH_VARARGS, NULL},
	 { "make_ta_explicit", _wrap_make_ta_explicit, METH_VARARGS, NULL},
	 { "new_tgta_explicit", _wrap_new_tgta_explicit, METH_VARARGS, NULL},
	 { "tgta_explicit_get_init_state", _wrap_tgta_explicit_get_init_state, METH_O, NULL},
	 { "tgta_explicit_get_ta", _wrap_tgta_explicit_get_ta, METH_VARARGS, NULL},
	 { "delete_tgta_explicit", _wrap_delete_tgta_explicit, METH_O, NULL},
	 { "tgta_explicit_swigregister", tgta_explicit_swigregister, METH_O, NULL},
	 { "tgta_explicit_swiginit", tgta_explicit_swiginit, METH_VARARGS, NULL},
	 { "make_tgta_explicit", _wrap_make_tgta_explicit, METH_VARARGS, NULL},
	 { "tgba_to_ta", _wrap_tgba_to_ta, METH_VARARGS, NULL},
	 { "tgba_to_tgta", _wrap_tgba_to_tgta, METH_VARARGS, NULL},
	 { "print_dot", _wrap_print_dot, METH_VARARGS, NULL},
	 { "ta_statistics_edges_set", _wrap_ta_statistics_edges_set, METH_VARARGS, NULL},
	 { "ta_statistics_edges_get", _wrap_ta_statistics_edges_get, METH_O, NULL},
	 { "ta_statistics_states_set", _wrap_ta_statistics_states_set, METH_VARARGS, NULL},
	 { "ta_statistics_states_get", _wrap_ta_statistics_states_get, METH_O, NULL},
	 { "ta_statistics_acceptance_states_set", _wrap_ta_statistics_acceptance_states_set, METH_VARARGS, NULL},
	 { "ta_statistics_acceptance_states_get", _wrap_ta_statistics_acceptance_states_get, METH_O, NULL},
	 { "ta_statistics_dump", _wrap_ta_statistics_dump, METH_VARARGS, NULL},
	 { "new_ta_statistics", _wrap_new_ta_statistics, METH_NOARGS, NULL},
	 { "delete_ta_statistics", _wrap_delete_ta_statistics, METH_O, NULL},
	 { "ta_statistics_swigregister", ta_statistics_swigregister, METH_O, NULL},
	 { "ta_statistics_swiginit", ta_statistics_swiginit, METH_VARARGS, NULL},
	 { "stats_reachable", _wrap_stats_reachable, METH_VARARGS, NULL},
	 { "minimize_ta", _wrap_minimize_ta, METH_O, NULL},
	 { "minimize_tgta", _wrap_minimize_tgta, METH_O, NULL},
	 { "delete_ostream", _wrap_delete_ostream, METH_O, NULL},
	 { "ostream_swigregister", ostream_swigregister, METH_O, NULL},
	 { "new_ofstream", _wrap_new_ofstream, METH_O, NULL},
	 { "delete_ofstream", _wrap_delete_ofstream, METH_O, NULL},
	 { "ofstream_swigregister", ofstream_swigregister, METH_O, NULL},
	 { "ofstream_swiginit", ofstream_swiginit, METH_VARARGS, NULL},
	 { "new_ostringstream", _wrap_new_ostringstream, METH_NOARGS, NULL},
	 { "ostringstream_str", _wrap_ostringstream_str, METH_O, NULL},
	 { "delete_ostringstream", _wrap_delete_ostringstream, METH_O, NULL},
	 { "ostringstream_swigregister", ostringstream_swigregister, METH_O, NULL},
	 { "ostringstream_swiginit", ostringstream_swiginit, METH_VARARGS, NULL},
	 { "fnode_instances_check", _wrap_fnode_instances_check, METH_NOARGS, NULL},
	 { "ensure_digraph", _wrap_ensure_digraph, METH_O, NULL},
	 { "get_cout", _wrap_get_cout, METH_NOARGS, NULL},
	 { "nl_cout", _wrap_nl_cout, METH_NOARGS, NULL},
	 { "get_cerr", _wrap_get_cerr, METH_NOARGS, NULL},
	 { "nl_cerr", _wrap_nl_cerr, METH_NOARGS, NULL},
	 { "print_on", _wrap_print_on, METH_VARARGS, NULL},
	 { "unblock_signal", _wrap_unblock_signal, METH_O, NULL},
	 { "states_and", _wrap_states_and, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};

static PyMethodDef SwigMethods_proxydocs[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL},
	 { "SwigPyIterator_incr", _wrap_SwigPyIterator_incr, METH_VARARGS, NULL},
	 { "SwigPyIterator_decr", _wrap_SwigPyIterator_decr, METH_VARARGS, NULL},
	 { "SwigPyIterator_distance", _wrap_SwigPyIterator_distance, METH_VARARGS, NULL},
	 { "SwigPyIterator_equal", _wrap_SwigPyIterator_equal, METH_VARARGS, 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", _wrap_SwigPyIterator_advance, METH_VARARGS, NULL},
	 { "SwigPyIterator___eq__", _wrap_SwigPyIterator___eq__, METH_VARARGS, NULL},
	 { "SwigPyIterator___ne__", _wrap_SwigPyIterator___ne__, METH_VARARGS, NULL},
	 { "SwigPyIterator___iadd__", _wrap_SwigPyIterator___iadd__, METH_VARARGS, NULL},
	 { "SwigPyIterator___isub__", _wrap_SwigPyIterator___isub__, METH_VARARGS, NULL},
	 { "SwigPyIterator___add__", _wrap_SwigPyIterator___add__, METH_VARARGS, NULL},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "new_parse_error", _wrap_new_parse_error, METH_O, NULL},
	 { "delete_parse_error", _wrap_delete_parse_error, METH_O, NULL},
	 { "parse_error_swigregister", parse_error_swigregister, METH_O, NULL},
	 { "parse_error_swiginit", parse_error_swiginit, METH_VARARGS, NULL},
	 { "new_parallel_policy", _wrap_new_parallel_policy, METH_VARARGS, NULL},
	 { "parallel_policy_nthreads", _wrap_parallel_policy_nthreads, METH_O, NULL},
	 { "delete_parallel_policy", _wrap_delete_parallel_policy, METH_O, NULL},
	 { "parallel_policy_swigregister", parallel_policy_swigregister, METH_O, NULL},
	 { "parallel_policy_swiginit", parallel_policy_swiginit, METH_VARARGS, NULL},
	 { "version", _wrap_version, METH_NOARGS, NULL},
	 { "new_minato_isop", _wrap_new_minato_isop, METH_VARARGS, NULL},
	 { "minato_isop_next", _wrap_minato_isop_next, METH_O, NULL},
	 { "delete_minato_isop", _wrap_delete_minato_isop, METH_O, NULL},
	 { "minato_isop_swigregister", minato_isop_swigregister, METH_O, NULL},
	 { "minato_isop_swiginit", minato_isop_swiginit, METH_VARARGS, NULL},
	 { "option_map_parse_options", _wrap_option_map_parse_options, METH_VARARGS, NULL},
	 { "option_map_get", _wrap_option_map_get, METH_VARARGS, NULL},
	 { "option_map_get_str", _wrap_option_map_get_str, METH_VARARGS, NULL},
	 { "option_map_set_if_unset", _wrap_option_map_set_if_unset, METH_VARARGS, NULL},
	 { "option_map_set_str", _wrap_option_map_set_str, METH_VARARGS, NULL},
	 { "option_map_report_unused_options", _wrap_option_map_report_unused_options, METH_O, NULL},
	 { "option_map_set", _wrap_option_map_set, METH_VARARGS, NULL},
	 { "new_option_map", _wrap_new_option_map, METH_NOARGS, NULL},
	 { "delete_option_map", _wrap_delete_option_map, METH_O, NULL},
	 { "option_map_swigregister", option_map_swigregister, METH_O, NULL},
	 { "option_map_swiginit", option_map_swiginit, METH_VARARGS, NULL},
	 { "srand", _wrap_srand, METH_O, NULL},
	 { "rrand", _wrap_rrand, METH_VARARGS, NULL},
	 { "mrand", _wrap_mrand, METH_O, NULL},
	 { "drand", _wrap_drand, METH_NOARGS, NULL},
	 { "nrand", _wrap_nrand, METH_NOARGS, NULL},
	 { "escape_rfc4180", _wrap_escape_rfc4180, METH_VARARGS, NULL},
	 { "escape_latex", _wrap_escape_latex, METH_VARARGS, NULL},
	 { "escape_html", _wrap_escape_html, METH_VARARGS, NULL},
	 { "escape_str", _wrap_escape_str, METH_VARARGS, NULL},
	 { "quote_shell_string", _wrap_quote_shell_string, METH_VARARGS, NULL},
	 { "new_trival", _wrap_new_trival, METH_VARARGS, NULL},
	 { "trival_maybe", _wrap_trival_maybe, METH_NOARGS, NULL},
	 { "trival_is_known", _wrap_trival_is_known, METH_O, NULL},
	 { "trival_is_maybe", _wrap_trival_is_maybe, METH_O, NULL},
	 { "trival_is_true", _wrap_trival_is_true, METH_O, NULL},
	 { "trival_is_false", _wrap_trival_is_false, METH_O, NULL},
	 { "trival_val", _wrap_trival_val, METH_O, NULL},
	 { "trival___nonzero__", _wrap_trival___nonzero__, METH_O, NULL},
	 { "trival___repr__", _wrap_trival___repr__, METH_O, NULL},
	 { "trival___str__", _wrap_trival___str__, METH_O, NULL},
	 { "trival___neg__", _wrap_trival___neg__, METH_O, NULL},
	 { "trival___and__", _wrap_trival___and__, METH_VARARGS, NULL},
	 { "trival___or__", _wrap_trival___or__, METH_VARARGS, NULL},
	 { "trival___eq__", _wrap_trival___eq__, METH_VARARGS, NULL},
	 { "trival___ne__", _wrap_trival___ne__, METH_VARARGS, NULL},
	 { "delete_trival", _wrap_delete_trival, METH_O, NULL},
	 { "trival_swigregister", trival_swigregister, METH_O, NULL},
	 { "trival_swiginit", trival_swiginit, METH_VARARGS, NULL},
	 { "new_formula", _wrap_new_formula, METH_VARARGS, NULL},
	 { "delete_formula", _wrap_delete_formula, METH_O, NULL},
	 { "formula___lt__", _wrap_formula___lt__, METH_VARARGS, NULL},
	 { "formula___le__", _wrap_formula___le__, METH_VARARGS, NULL},
	 { "formula___gt__", _wrap_formula___gt__, METH_VARARGS, NULL},
	 { "formula___ge__", _wrap_formula___ge__, METH_VARARGS, NULL},
	 { "formula___eq__", _wrap_formula___eq__, METH_VARARGS, NULL},
	 { "formula___ne__", _wrap_formula___ne__, METH_VARARGS, NULL},
	 { "formula___nonzero__", _wrap_formula___nonzero__, METH_O, NULL},
	 { "formula_unbounded", _wrap_formula_unbounded, METH_NOARGS, NULL},
	 { "formula_ap", _wrap_formula_ap, METH_VARARGS, NULL},
	 { "formula_unop", _wrap_formula_unop, METH_VARARGS, NULL},
	 { "formula_Not", _wrap_formula_Not, METH_O, NULL},
	 { "formula_X", _wrap_formula_X, METH_VARARGS, NULL},
	 { "formula_F", _wrap_formula_F, METH_VARARGS, NULL},
	 { "formula_G", _wrap_formula_G, METH_VARARGS, NULL},
	 { "formula_Closure", _wrap_formula_Closure, METH_O, NULL},
	 { "formula_NegClosure", _wrap_formula_NegClosure, METH_O, NULL},
	 { "formula_NegClosureMarked", _wrap_formula_NegClosureMarked, METH_O, NULL},
	 { "formula_first_match", _wrap_formula_first_match, METH_O, NULL},
	 { "formula_binop", _wrap_formula_binop, METH_VARARGS, NULL},
	 { "formula_Xor", _wrap_formula_Xor, METH_VARARGS, NULL},
	 { "formula_Implies", _wrap_formula_Implies, METH_VARARGS, NULL},
	 { "formula_Equiv", _wrap_formula_Equiv, METH_VARARGS, NULL},
	 { "formula_U", _wrap_formula_U, METH_VARARGS, NULL},
	 { "formula_R", _wrap_formula_R, METH_VARARGS, NULL},
	 { "formula_W", _wrap_formula_W, METH_VARARGS, NULL},
	 { "formula_M", _wrap_formula_M, METH_VARARGS, NULL},
	 { "formula_EConcat", _wrap_formula_EConcat, METH_VARARGS, NULL},
	 { "formula_EConcatMarked", _wrap_formula_EConcatMarked, METH_VARARGS, NULL},
	 { "formula_UConcat", _wrap_formula_UConcat, METH_VARARGS, NULL},
	 { "formula_multop", _wrap_formula_multop, METH_VARARGS, NULL},
	 { "formula_Or", _wrap_formula_Or, METH_O, NULL},
	 { "formula_OrRat", _wrap_formula_OrRat, METH_O, NULL},
	 { "formula_And", _wrap_formula_And, METH_O, NULL},
	 { "formula_AndRat", _wrap_formula_AndRat, METH_O, NULL},
	 { "formula_AndNLM", _wrap_formula_AndNLM, METH_O, NULL},
	 { "formula_Concat", _wrap_formula_Concat, METH_O, NULL},
	 { "formula_Fusion", _wrap_formula_Fusion, METH_O, NULL},
	 { "formula_bunop", _wrap_formula_bunop, METH_VARARGS, NULL},
	 { "formula_Star", _wrap_formula_Star, METH_VARARGS, NULL},
	 { "formula_FStar", _wrap_formula_FStar, METH_VARARGS, NULL},
	 { "formula_nested_unop_range", _wrap_formula_nested_unop_range, METH_VARARGS, NULL},
	 { "formula_sugar_goto", _wrap_formula_sugar_goto, METH_VARARGS, NULL},
	 { "formula_sugar_equal", _wrap_formula_sugar_equal, METH_VARARGS, NULL},
	 { "formula_sugar_delay", _wrap_formula_sugar_delay, METH_VARARGS, NULL},
	 { "formula_kind", _wrap_formula_kind, METH_O, NULL},
	 { "formula_kindstr", _wrap_formula_kindstr, METH_O, NULL},
	 { "formula__is", _wrap_formula__is, METH_VARARGS, NULL},
	 { "formula_get_child_of", _wrap_formula_get_child_of, METH_VARARGS, NULL},
	 { "formula_min", _wrap_formula_min, METH_O, NULL},
	 { "formula_max", _wrap_formula_max, METH_O, NULL},
	 { "formula_size", _wrap_formula_size, METH_O, NULL},
	 { "formula_is_leaf", _wrap_formula_is_leaf, METH_O, NULL},
	 { "formula_id", _wrap_formula_id, METH_O, NULL},
	 { "formula_ff", _wrap_formula_ff, METH_NOARGS, NULL},
	 { "formula_is_ff", _wrap_formula_is_ff, METH_O, NULL},
	 { "formula_tt", _wrap_formula_tt, METH_NOARGS, NULL},
	 { "formula_is_tt", _wrap_formula_is_tt, METH_O, NULL},
	 { "formula_eword", _wrap_formula_eword, METH_NOARGS, NULL},
	 { "formula_is_eword", _wrap_formula_is_eword, METH_O, NULL},
	 { "formula_is_constant", _wrap_formula_is_constant, METH_O, NULL},
	 { "formula_is_Kleene_star", _wrap_formula_is_Kleene_star, METH_O, NULL},
	 { "formula_one_star", _wrap_formula_one_star, METH_NOARGS, NULL},
	 { "formula_one_plus", _wrap_formula_one_plus, METH_NOARGS, NULL},
	 { "formula_is_literal", _wrap_formula_is_literal, METH_O, NULL},
	 { "formula_ap_name", _wrap_formula_ap_name, METH_O, NULL},
	 { "formula_dump", _wrap_formula_dump, METH_VARARGS, NULL},
	 { "formula_all_but", _wrap_formula_all_but, METH_VARARGS, NULL},
	 { "formula_boolean_count", _wrap_formula_boolean_count, METH_O, NULL},
	 { "formula_boolean_operands", _wrap_formula_boolean_operands, METH_VARARGS, NULL},
	 { "formula_is_boolean", _wrap_formula_is_boolean, METH_O, NULL},
	 { "formula_is_sugar_free_boolean", _wrap_formula_is_sugar_free_boolean, METH_O, NULL},
	 { "formula_is_in_nenoform", _wrap_formula_is_in_nenoform, METH_O, NULL},
	 { "formula_is_syntactic_stutter_invariant", _wrap_formula_is_syntactic_stutter_invariant, METH_O, NULL},
	 { "formula_is_sugar_free_ltl", _wrap_formula_is_sugar_free_ltl, METH_O, NULL},
	 { "formula_is_ltl_formula", _wrap_formula_is_ltl_formula, METH_O, NULL},
	 { "formula_is_psl_formula", _wrap_formula_is_psl_formula, METH_O, NULL},
	 { "formula_is_sere_formula", _wrap_formula_is_sere_formula, METH_O, NULL},
	 { "formula_is_finite", _wrap_formula_is_finite, METH_O, NULL},
	 { "formula_is_eventual", _wrap_formula_is_eventual, METH_O, NULL},
	 { "formula_is_universal", _wrap_formula_is_universal, METH_O, NULL},
	 { "formula_is_syntactic_safety", _wrap_formula_is_syntactic_safety, METH_O, NULL},
	 { "formula_is_syntactic_guarantee", _wrap_formula_is_syntactic_guarantee, METH_O, NULL},
	 { "formula_is_syntactic_obligation", _wrap_formula_is_syntactic_obligation, METH_O, NULL},
	 { "formula_is_syntactic_recurrence", _wrap_formula_is_syntactic_recurrence, METH_O, NULL},
	 { "formula_is_syntactic_persistence", _wrap_formula_is_syntactic_persistence, METH_O, NULL},
	 { "formula_is_marked", _wrap_formula_is_marked, METH_O, NULL},
	 { "formula_accepts_eword", _wrap_formula_accepts_eword, METH_O, NULL},
	 { "formula_has_lbt_atomic_props", _wrap_formula_has_lbt_atomic_props, METH_O, NULL},
	 { "formula_has_spin_atomic_props", _wrap_formula_has_spin_atomic_props, METH_O, NULL},
	 { "formula___cmp__", _wrap_formula___cmp__, METH_VARARGS, NULL},
	 { "formula___hash__", _wrap_formula___hash__, METH_O, NULL},
	 { "formula___len__", _wrap_formula___len__, METH_O, NULL},
	 { "formula___getitem__", _wrap_formula___getitem__, METH_VARARGS, NULL},
	 { "formula___repr__", _wrap_formula___repr__, METH_O, NULL},
	 { "formula___str__", _wrap_formula___str__, METH_O, NULL},
	 { "formula_swigregister", formula_swigregister, METH_O, NULL},
	 { "formula_swiginit", formula_swiginit, METH_VARARGS, NULL},
	 { "print_formula_props", _wrap_print_formula_props, METH_VARARGS, NULL},
	 { "list_formula_props", _wrap_list_formula_props, METH_O, NULL},
	 { "liststr_iterator", _wrap_liststr_iterator, METH_O, NULL},
	 { "liststr___nonzero__", _wrap_liststr___nonzero__, METH_O, NULL},
	 { "liststr___bool__", _wrap_liststr___bool__, METH_O, NULL},
	 { "liststr___len__", _wrap_liststr___len__, METH_O, NULL},
	 { "liststr___getslice__", _wrap_liststr___getslice__, METH_VARARGS, NULL},
	 { "liststr___setslice__", _wrap_liststr___setslice__, METH_VARARGS, NULL},
	 { "liststr___delslice__", _wrap_liststr___delslice__, METH_VARARGS, NULL},
	 { "liststr___delitem__", _wrap_liststr___delitem__, METH_VARARGS, NULL},
	 { "liststr___getitem__", _wrap_liststr___getitem__, METH_VARARGS, NULL},
	 { "liststr___setitem__", _wrap_liststr___setitem__, METH_VARARGS, NULL},
	 { "liststr_pop", _wrap_liststr_pop, METH_O, NULL},
	 { "liststr_append", _wrap_liststr_append, METH_VARARGS, NULL},
	 { "liststr_empty", _wrap_liststr_empty, METH_O, NULL},
	 { "liststr_size", _wrap_liststr_size, METH_O, NULL},
	 { "liststr_swap", _wrap_liststr_swap, METH_VARARGS, NULL},
	 { "liststr_begin", _wrap_liststr_begin, METH_O, NULL},
	 { "liststr_end", _wrap_liststr_end, METH_O, NULL},
	 { "liststr_rbegin", _wrap_liststr_rbegin, METH_O, NULL},
	 { "liststr_rend", _wrap_liststr_rend, METH_O, NULL},
	 { "liststr_clear", _wrap_liststr_clear, METH_O, NULL},
	 { "liststr_get_allocator", _wrap_liststr_get_allocator, METH_O, NULL},
	 { "liststr_pop_back", _wrap_liststr_pop_back, METH_O, NULL},
	 { "liststr_erase", _wrap_liststr_erase, METH_VARARGS, NULL},
	 { "new_liststr", _wrap_new_liststr, METH_VARARGS, NULL},
	 { "liststr_push_back", _wrap_liststr_push_back, METH_VARARGS, NULL},
	 { "liststr_front", _wrap_liststr_front, METH_O, NULL},
	 { "liststr_back", _wrap_liststr_back, METH_O, NULL},
	 { "liststr_assign", _wrap_liststr_assign, METH_VARARGS, NULL},
	 { "liststr_resize", _wrap_liststr_resize, METH_VARARGS, NULL},
	 { "liststr_insert", _wrap_liststr_insert, METH_VARARGS, NULL},
	 { "liststr_pop_front", _wrap_liststr_pop_front, METH_O, NULL},
	 { "liststr_push_front", _wrap_liststr_push_front, METH_VARARGS, NULL},
	 { "liststr_reverse", _wrap_liststr_reverse, METH_O, NULL},
	 { "delete_liststr", _wrap_delete_liststr, METH_O, NULL},
	 { "liststr_swigregister", liststr_swigregister, METH_O, NULL},
	 { "liststr_swiginit", liststr_swiginit, METH_VARARGS, NULL},
	 { "new_pairunsigned", _wrap_new_pairunsigned, METH_VARARGS, NULL},
	 { "pairunsigned_first_set", _wrap_pairunsigned_first_set, METH_VARARGS, NULL},
	 { "pairunsigned_first_get", _wrap_pairunsigned_first_get, METH_O, NULL},
	 { "pairunsigned_second_set", _wrap_pairunsigned_second_set, METH_VARARGS, NULL},
	 { "pairunsigned_second_get", _wrap_pairunsigned_second_get, METH_O, NULL},
	 { "delete_pairunsigned", _wrap_delete_pairunsigned, METH_O, NULL},
	 { "pairunsigned_swigregister", pairunsigned_swigregister, METH_O, NULL},
	 { "pairunsigned_swiginit", pairunsigned_swiginit, METH_VARARGS, NULL},
	 { "new_pairmark_t", _wrap_new_pairmark_t, METH_VARARGS, NULL},
	 { "pairmark_t_first_set", _wrap_pairmark_t_first_set, METH_VARARGS, NULL},
	 { "pairmark_t_first_get", _wrap_pairmark_t_first_get, METH_O, NULL},
	 { "pairmark_t_second_set", _wrap_pairmark_t_second_set, METH_VARARGS, NULL},
	 { "pairmark_t_second_get", _wrap_pairmark_t_second_get, METH_O, NULL},
	 { "delete_pairmark_t", _wrap_delete_pairmark_t, METH_O, NULL},
	 { "pairmark_t_swigregister", pairmark_t_swigregister, METH_O, NULL},
	 { "pairmark_t_swiginit", pairmark_t_swiginit, METH_VARARGS, NULL},
	 { "new_pairintacccode", _wrap_new_pairintacccode, METH_VARARGS, NULL},
	 { "pairintacccode_first_set", _wrap_pairintacccode_first_set, METH_VARARGS, NULL},
	 { "pairintacccode_first_get", _wrap_pairintacccode_first_get, METH_O, NULL},
	 { "pairintacccode_second_set", _wrap_pairintacccode_second_set, METH_VARARGS, NULL},
	 { "pairintacccode_second_get", _wrap_pairintacccode_second_get, METH_O, NULL},
	 { "delete_pairintacccode", _wrap_delete_pairintacccode, METH_O, NULL},
	 { "pairintacccode_swigregister", pairintacccode_swigregister, METH_O, NULL},
	 { "pairintacccode_swiginit", pairintacccode_swiginit, METH_VARARGS, NULL},
	 { "new_pairintacccond", _wrap_new_pairintacccond, METH_VARARGS, NULL},
	 { "pairintacccond_first_set", _wrap_pairintacccond_first_set, METH_VARARGS, NULL},
	 { "pairintacccond_first_get", _wrap_pairintacccond_first_get, METH_O, NULL},
	 { "pairintacccond_second_set", _wrap_pairintacccond_second_set, METH_VARARGS, NULL},
	 { "pairintacccond_second_get", _wrap_pairintacccond_second_get, METH_O, NULL},
	 { "delete_pairintacccond", _wrap_delete_pairintacccond, METH_O, NULL},
	 { "pairintacccond_swigregister", pairintacccond_swigregister, METH_O, NULL},
	 { "pairintacccond_swiginit", pairintacccond_swiginit, METH_VARARGS, NULL},
	 { "vectorformula_iterator", _wrap_vectorformula_iterator, METH_O, NULL},
	 { "vectorformula___nonzero__", _wrap_vectorformula___nonzero__, METH_O, NULL},
	 { "vectorformula___bool__", _wrap_vectorformula___bool__, METH_O, NULL},
	 { "vectorformula___len__", _wrap_vectorformula___len__, METH_O, NULL},
	 { "vectorformula___getslice__", _wrap_vectorformula___getslice__, METH_VARARGS, NULL},
	 { "vectorformula___setslice__", _wrap_vectorformula___setslice__, METH_VARARGS, NULL},
	 { "vectorformula___delslice__", _wrap_vectorformula___delslice__, METH_VARARGS, NULL},
	 { "vectorformula___delitem__", _wrap_vectorformula___delitem__, METH_VARARGS, NULL},
	 { "vectorformula___getitem__", _wrap_vectorformula___getitem__, METH_VARARGS, NULL},
	 { "vectorformula___setitem__", _wrap_vectorformula___setitem__, METH_VARARGS, NULL},
	 { "vectorformula_pop", _wrap_vectorformula_pop, METH_O, NULL},
	 { "vectorformula_append", _wrap_vectorformula_append, METH_VARARGS, NULL},
	 { "vectorformula_empty", _wrap_vectorformula_empty, METH_O, NULL},
	 { "vectorformula_size", _wrap_vectorformula_size, METH_O, NULL},
	 { "vectorformula_swap", _wrap_vectorformula_swap, METH_VARARGS, NULL},
	 { "vectorformula_begin", _wrap_vectorformula_begin, METH_O, NULL},
	 { "vectorformula_end", _wrap_vectorformula_end, METH_O, NULL},
	 { "vectorformula_rbegin", _wrap_vectorformula_rbegin, METH_O, NULL},
	 { "vectorformula_rend", _wrap_vectorformula_rend, METH_O, NULL},
	 { "vectorformula_clear", _wrap_vectorformula_clear, METH_O, NULL},
	 { "vectorformula_get_allocator", _wrap_vectorformula_get_allocator, METH_O, NULL},
	 { "vectorformula_pop_back", _wrap_vectorformula_pop_back, METH_O, NULL},
	 { "vectorformula_erase", _wrap_vectorformula_erase, METH_VARARGS, NULL},
	 { "new_vectorformula", _wrap_new_vectorformula, METH_VARARGS, NULL},
	 { "vectorformula_push_back", _wrap_vectorformula_push_back, METH_VARARGS, NULL},
	 { "vectorformula_front", _wrap_vectorformula_front, METH_O, NULL},
	 { "vectorformula_back", _wrap_vectorformula_back, METH_O, NULL},
	 { "vectorformula_assign", _wrap_vectorformula_assign, METH_VARARGS, NULL},
	 { "vectorformula_resize", _wrap_vectorformula_resize, METH_VARARGS, NULL},
	 { "vectorformula_insert", _wrap_vectorformula_insert, METH_VARARGS, NULL},
	 { "vectorformula_reserve", _wrap_vectorformula_reserve, METH_VARARGS, NULL},
	 { "vectorformula_capacity", _wrap_vectorformula_capacity, METH_O, NULL},
	 { "delete_vectorformula", _wrap_delete_vectorformula, METH_O, NULL},
	 { "vectorformula_swigregister", vectorformula_swigregister, METH_O, NULL},
	 { "vectorformula_swiginit", vectorformula_swiginit, METH_VARARGS, NULL},
	 { "vectorunsigned_iterator", _wrap_vectorunsigned_iterator, METH_O, NULL},
	 { "vectorunsigned___nonzero__", _wrap_vectorunsigned___nonzero__, METH_O, NULL},
	 { "vectorunsigned___bool__", _wrap_vectorunsigned___bool__, METH_O, NULL},
	 { "vectorunsigned___len__", _wrap_vectorunsigned___len__, METH_O, NULL},
	 { "vectorunsigned___getslice__", _wrap_vectorunsigned___getslice__, METH_VARARGS, NULL},
	 { "vectorunsigned___setslice__", _wrap_vectorunsigned___setslice__, METH_VARARGS, NULL},
	 { "vectorunsigned___delslice__", _wrap_vectorunsigned___delslice__, METH_VARARGS, NULL},
	 { "vectorunsigned___delitem__", _wrap_vectorunsigned___delitem__, METH_VARARGS, NULL},
	 { "vectorunsigned___getitem__", _wrap_vectorunsigned___getitem__, METH_VARARGS, NULL},
	 { "vectorunsigned___setitem__", _wrap_vectorunsigned___setitem__, METH_VARARGS, NULL},
	 { "vectorunsigned_pop", _wrap_vectorunsigned_pop, METH_O, NULL},
	 { "vectorunsigned_append", _wrap_vectorunsigned_append, METH_VARARGS, NULL},
	 { "vectorunsigned_empty", _wrap_vectorunsigned_empty, METH_O, NULL},
	 { "vectorunsigned_size", _wrap_vectorunsigned_size, METH_O, NULL},
	 { "vectorunsigned_swap", _wrap_vectorunsigned_swap, METH_VARARGS, NULL},
	 { "vectorunsigned_begin", _wrap_vectorunsigned_begin, METH_O, NULL},
	 { "vectorunsigned_end", _wrap_vectorunsigned_end, METH_O, NULL},
	 { "vectorunsigned_rbegin", _wrap_vectorunsigned_rbegin, METH_O, NULL},
	 { "vectorunsigned_rend", _wrap_vectorunsigned_rend, METH_O, NULL},
	 { "vectorunsigned_clear", _wrap_vectorunsigned_clear, METH_O, NULL},
	 { "vectorunsigned_get_allocator", _wrap_vectorunsigned_get_allocator, METH_O, NULL},
	 { "vectorunsigned_pop_back", _wrap_vectorunsigned_pop_back, METH_O, NULL},
	 { "vectorunsigned_erase", _wrap_vectorunsigned_erase, METH_VARARGS, NULL},
	 { "new_vectorunsigned", _wrap_new_vectorunsigned, METH_VARARGS, NULL},
	 { "vectorunsigned_push_back", _wrap_vectorunsigned_push_back, METH_VARARGS, NULL},
	 { "vectorunsigned_front", _wrap_vectorunsigned_front, METH_O, NULL},
	 { "vectorunsigned_back", _wrap_vectorunsigned_back, METH_O, NULL},
	 { "vectorunsigned_assign", _wrap_vectorunsigned_assign, METH_VARARGS, NULL},
	 { "vectorunsigned_resize", _wrap_vectorunsigned_resize, METH_VARARGS, NULL},
	 { "vectorunsigned_insert", _wrap_vectorunsigned_insert, METH_VARARGS, NULL},
	 { "vectorunsigned_reserve", _wrap_vectorunsigned_reserve, METH_VARARGS, NULL},
	 { "vectorunsigned_capacity", _wrap_vectorunsigned_capacity, METH_O, NULL},
	 { "delete_vectorunsigned", _wrap_delete_vectorunsigned, METH_O, NULL},
	 { "vectorunsigned_swigregister", vectorunsigned_swigregister, METH_O, NULL},
	 { "vectorunsigned_swiginit", vectorunsigned_swiginit, METH_VARARGS, NULL},
	 { "vectorpairunsigned_iterator", _wrap_vectorpairunsigned_iterator, METH_O, NULL},
	 { "vectorpairunsigned___nonzero__", _wrap_vectorpairunsigned___nonzero__, METH_O, NULL},
	 { "vectorpairunsigned___bool__", _wrap_vectorpairunsigned___bool__, METH_O, NULL},
	 { "vectorpairunsigned___len__", _wrap_vectorpairunsigned___len__, METH_O, NULL},
	 { "vectorpairunsigned___getslice__", _wrap_vectorpairunsigned___getslice__, METH_VARARGS, NULL},
	 { "vectorpairunsigned___setslice__", _wrap_vectorpairunsigned___setslice__, METH_VARARGS, NULL},
	 { "vectorpairunsigned___delslice__", _wrap_vectorpairunsigned___delslice__, METH_VARARGS, NULL},
	 { "vectorpairunsigned___delitem__", _wrap_vectorpairunsigned___delitem__, METH_VARARGS, NULL},
	 { "vectorpairunsigned___getitem__", _wrap_vectorpairunsigned___getitem__, METH_VARARGS, NULL},
	 { "vectorpairunsigned___setitem__", _wrap_vectorpairunsigned___setitem__, METH_VARARGS, NULL},
	 { "vectorpairunsigned_pop", _wrap_vectorpairunsigned_pop, METH_O, NULL},
	 { "vectorpairunsigned_append", _wrap_vectorpairunsigned_append, METH_VARARGS, NULL},
	 { "vectorpairunsigned_empty", _wrap_vectorpairunsigned_empty, METH_O, NULL},
	 { "vectorpairunsigned_size", _wrap_vectorpairunsigned_size, METH_O, NULL},
	 { "vectorpairunsigned_swap", _wrap_vectorpairunsigned_swap, METH_VARARGS, NULL},
	 { "vectorpairunsigned_begin", _wrap_vectorpairunsigned_begin, METH_O, NULL},
	 { "vectorpairunsigned_end", _wrap_vectorpairunsigned_end, METH_O, NULL},
	 { "vectorpairunsigned_rbegin", _wrap_vectorpairunsigned_rbegin, METH_O, NULL},
	 { "vectorpairunsigned_rend", _wrap_vectorpairunsigned_rend, METH_O, NULL},
	 { "vectorpairunsigned_clear", _wrap_vectorpairunsigned_clear, METH_O, NULL},
	 { "vectorpairunsigned_get_allocator", _wrap_vectorpairunsigned_get_allocator, METH_O, NULL},
	 { "vectorpairunsigned_pop_back", _wrap_vectorpairunsigned_pop_back, METH_O, NULL},
	 { "vectorpairunsigned_erase", _wrap_vectorpairunsigned_erase, METH_VARARGS, NULL},
	 { "new_vectorpairunsigned", _wrap_new_vectorpairunsigned, METH_VARARGS, NULL},
	 { "vectorpairunsigned_push_back", _wrap_vectorpairunsigned_push_back, METH_VARARGS, NULL},
	 { "vectorpairunsigned_front", _wrap_vectorpairunsigned_front, METH_O, NULL},
	 { "vectorpairunsigned_back", _wrap_vectorpairunsigned_back, METH_O, NULL},
	 { "vectorpairunsigned_assign", _wrap_vectorpairunsigned_assign, METH_VARARGS, NULL},
	 { "vectorpairunsigned_resize", _wrap_vectorpairunsigned_resize, METH_VARARGS, NULL},
	 { "vectorpairunsigned_insert", _wrap_vectorpairunsigned_insert, METH_VARARGS, NULL},
	 { "vectorpairunsigned_reserve", _wrap_vectorpairunsigned_reserve, METH_VARARGS, NULL},
	 { "vectorpairunsigned_capacity", _wrap_vectorpairunsigned_capacity, METH_O, NULL},
	 { "delete_vectorpairunsigned", _wrap_delete_vectorpairunsigned, METH_O, NULL},
	 { "vectorpairunsigned_swigregister", vectorpairunsigned_swigregister, METH_O, NULL},
	 { "vectorpairunsigned_swiginit", vectorpairunsigned_swiginit, METH_VARARGS, NULL},
	 { "vectoracccond_iterator", _wrap_vectoracccond_iterator, METH_O, NULL},
	 { "vectoracccond___nonzero__", _wrap_vectoracccond___nonzero__, METH_O, NULL},
	 { "vectoracccond___bool__", _wrap_vectoracccond___bool__, METH_O, NULL},
	 { "vectoracccond___len__", _wrap_vectoracccond___len__, METH_O, NULL},
	 { "vectoracccond___getslice__", _wrap_vectoracccond___getslice__, METH_VARARGS, NULL},
	 { "vectoracccond___setslice__", _wrap_vectoracccond___setslice__, METH_VARARGS, NULL},
	 { "vectoracccond___delslice__", _wrap_vectoracccond___delslice__, METH_VARARGS, NULL},
	 { "vectoracccond___delitem__", _wrap_vectoracccond___delitem__, METH_VARARGS, NULL},
	 { "vectoracccond___getitem__", _wrap_vectoracccond___getitem__, METH_VARARGS, NULL},
	 { "vectoracccond___setitem__", _wrap_vectoracccond___setitem__, METH_VARARGS, NULL},
	 { "vectoracccond_pop", _wrap_vectoracccond_pop, METH_O, NULL},
	 { "vectoracccond_append", _wrap_vectoracccond_append, METH_VARARGS, NULL},
	 { "vectoracccond_empty", _wrap_vectoracccond_empty, METH_O, NULL},
	 { "vectoracccond_size", _wrap_vectoracccond_size, METH_O, NULL},
	 { "vectoracccond_swap", _wrap_vectoracccond_swap, METH_VARARGS, NULL},
	 { "vectoracccond_begin", _wrap_vectoracccond_begin, METH_O, NULL},
	 { "vectoracccond_end", _wrap_vectoracccond_end, METH_O, NULL},
	 { "vectoracccond_rbegin", _wrap_vectoracccond_rbegin, METH_O, NULL},
	 { "vectoracccond_rend", _wrap_vectoracccond_rend, METH_O, NULL},
	 { "vectoracccond_clear", _wrap_vectoracccond_clear, METH_O, NULL},
	 { "vectoracccond_get_allocator", _wrap_vectoracccond_get_allocator, METH_O, NULL},
	 { "vectoracccond_pop_back", _wrap_vectoracccond_pop_back, METH_O, NULL},
	 { "vectoracccond_erase", _wrap_vectoracccond_erase, METH_VARARGS, NULL},
	 { "new_vectoracccond", _wrap_new_vectoracccond, METH_VARARGS, NULL},
	 { "vectoracccond_push_back", _wrap_vectoracccond_push_back, METH_VARARGS, NULL},
	 { "vectoracccond_front", _wrap_vectoracccond_front, METH_O, NULL},
	 { "vectoracccond_back", _wrap_vectoracccond_back, METH_O, NULL},
	 { "vectoracccond_assign", _wrap_vectoracccond_assign, METH_VARARGS, NULL},
	 { "vectoracccond_resize", _wrap_vectoracccond_resize, METH_VARARGS, NULL},
	 { "vectoracccond_insert", _wrap_vectoracccond_insert, METH_VARARGS, NULL},
	 { "vectoracccond_reserve", _wrap_vectoracccond_reserve, METH_VARARGS, NULL},
	 { "vectoracccond_capacity", _wrap_vectoracccond_capacity, METH_O, NULL},
	 { "delete_vectoracccond", _wrap_delete_vectoracccond, METH_O, NULL},
	 { "vectoracccond_swigregister", vectoracccond_swigregister, METH_O, NULL},
	 { "vectoracccond_swiginit", vectoracccond_swiginit, METH_VARARGS, NULL},
	 { "vectoracccode_iterator", _wrap_vectoracccode_iterator, METH_O, NULL},
	 { "vectoracccode___nonzero__", _wrap_vectoracccode___nonzero__, METH_O, NULL},
	 { "vectoracccode___bool__", _wrap_vectoracccode___bool__, METH_O, NULL},
	 { "vectoracccode___len__", _wrap_vectoracccode___len__, METH_O, NULL},
	 { "vectoracccode___getslice__", _wrap_vectoracccode___getslice__, METH_VARARGS, NULL},
	 { "vectoracccode___setslice__", _wrap_vectoracccode___setslice__, METH_VARARGS, NULL},
	 { "vectoracccode___delslice__", _wrap_vectoracccode___delslice__, METH_VARARGS, NULL},
	 { "vectoracccode___delitem__", _wrap_vectoracccode___delitem__, METH_VARARGS, NULL},
	 { "vectoracccode___getitem__", _wrap_vectoracccode___getitem__, METH_VARARGS, NULL},
	 { "vectoracccode___setitem__", _wrap_vectoracccode___setitem__, METH_VARARGS, NULL},
	 { "vectoracccode_pop", _wrap_vectoracccode_pop, METH_O, NULL},
	 { "vectoracccode_append", _wrap_vectoracccode_append, METH_VARARGS, NULL},
	 { "vectoracccode_empty", _wrap_vectoracccode_empty, METH_O, NULL},
	 { "vectoracccode_size", _wrap_vectoracccode_size, METH_O, NULL},
	 { "vectoracccode_swap", _wrap_vectoracccode_swap, METH_VARARGS, NULL},
	 { "vectoracccode_begin", _wrap_vectoracccode_begin, METH_O, NULL},
	 { "vectoracccode_end", _wrap_vectoracccode_end, METH_O, NULL},
	 { "vectoracccode_rbegin", _wrap_vectoracccode_rbegin, METH_O, NULL},
	 { "vectoracccode_rend", _wrap_vectoracccode_rend, METH_O, NULL},
	 { "vectoracccode_clear", _wrap_vectoracccode_clear, METH_O, NULL},
	 { "vectoracccode_get_allocator", _wrap_vectoracccode_get_allocator, METH_O, NULL},
	 { "vectoracccode_pop_back", _wrap_vectoracccode_pop_back, METH_O, NULL},
	 { "vectoracccode_erase", _wrap_vectoracccode_erase, METH_VARARGS, NULL},
	 { "new_vectoracccode", _wrap_new_vectoracccode, METH_VARARGS, NULL},
	 { "vectoracccode_push_back", _wrap_vectoracccode_push_back, METH_VARARGS, NULL},
	 { "vectoracccode_front", _wrap_vectoracccode_front, METH_O, NULL},
	 { "vectoracccode_back", _wrap_vectoracccode_back, METH_O, NULL},
	 { "vectoracccode_assign", _wrap_vectoracccode_assign, METH_VARARGS, NULL},
	 { "vectoracccode_resize", _wrap_vectoracccode_resize, METH_VARARGS, NULL},
	 { "vectoracccode_insert", _wrap_vectoracccode_insert, METH_VARARGS, NULL},
	 { "vectoracccode_reserve", _wrap_vectoracccode_reserve, METH_VARARGS, NULL},
	 { "vectoracccode_capacity", _wrap_vectoracccode_capacity, METH_O, NULL},
	 { "delete_vectoracccode", _wrap_delete_vectoracccode, METH_O, NULL},
	 { "vectoracccode_swigregister", vectoracccode_swigregister, METH_O, NULL},
	 { "vectoracccode_swiginit", vectoracccode_swiginit, METH_VARARGS, NULL},
	 { "vectorbool_iterator", _wrap_vectorbool_iterator, METH_O, NULL},
	 { "vectorbool___nonzero__", _wrap_vectorbool___nonzero__, METH_O, NULL},
	 { "vectorbool___bool__", _wrap_vectorbool___bool__, METH_O, NULL},
	 { "vectorbool___len__", _wrap_vectorbool___len__, METH_O, NULL},
	 { "vectorbool___getslice__", _wrap_vectorbool___getslice__, METH_VARARGS, NULL},
	 { "vectorbool___setslice__", _wrap_vectorbool___setslice__, METH_VARARGS, NULL},
	 { "vectorbool___delslice__", _wrap_vectorbool___delslice__, METH_VARARGS, NULL},
	 { "vectorbool___delitem__", _wrap_vectorbool___delitem__, METH_VARARGS, NULL},
	 { "vectorbool___getitem__", _wrap_vectorbool___getitem__, METH_VARARGS, NULL},
	 { "vectorbool___setitem__", _wrap_vectorbool___setitem__, METH_VARARGS, NULL},
	 { "vectorbool_pop", _wrap_vectorbool_pop, METH_O, NULL},
	 { "vectorbool_append", _wrap_vectorbool_append, METH_VARARGS, NULL},
	 { "vectorbool_empty", _wrap_vectorbool_empty, METH_O, NULL},
	 { "vectorbool_size", _wrap_vectorbool_size, METH_O, NULL},
	 { "vectorbool_swap", _wrap_vectorbool_swap, METH_VARARGS, NULL},
	 { "vectorbool_begin", _wrap_vectorbool_begin, METH_O, NULL},
	 { "vectorbool_end", _wrap_vectorbool_end, METH_O, NULL},
	 { "vectorbool_rbegin", _wrap_vectorbool_rbegin, METH_O, NULL},
	 { "vectorbool_rend", _wrap_vectorbool_rend, METH_O, NULL},
	 { "vectorbool_clear", _wrap_vectorbool_clear, METH_O, NULL},
	 { "vectorbool_get_allocator", _wrap_vectorbool_get_allocator, METH_O, NULL},
	 { "vectorbool_pop_back", _wrap_vectorbool_pop_back, METH_O, NULL},
	 { "vectorbool_erase", _wrap_vectorbool_erase, METH_VARARGS, NULL},
	 { "new_vectorbool", _wrap_new_vectorbool, METH_VARARGS, NULL},
	 { "vectorbool_push_back", _wrap_vectorbool_push_back, METH_VARARGS, NULL},
	 { "vectorbool_front", _wrap_vectorbool_front, METH_O, NULL},
	 { "vectorbool_back", _wrap_vectorbool_back, METH_O, NULL},
	 { "vectorbool_assign", _wrap_vectorbool_assign, METH_VARARGS, NULL},
	 { "vectorbool_resize", _wrap_vectorbool_resize, METH_VARARGS, NULL},
	 { "vectorbool_insert", _wrap_vectorbool_insert, METH_VARARGS, NULL},
	 { "vectorbool_reserve", _wrap_vectorbool_reserve, METH_VARARGS, NULL},
	 { "vectorbool_capacity", _wrap_vectorbool_capacity, METH_O, NULL},
	 { "delete_vectorbool", _wrap_delete_vectorbool, METH_O, NULL},
	 { "vectorbool_swigregister", vectorbool_swigregister, METH_O, NULL},
	 { "vectorbool_swiginit", vectorbool_swiginit, METH_VARARGS, NULL},
	 { "vectorbdd_iterator", _wrap_vectorbdd_iterator, METH_O, NULL},
	 { "vectorbdd___nonzero__", _wrap_vectorbdd___nonzero__, METH_O, NULL},
	 { "vectorbdd___bool__", _wrap_vectorbdd___bool__, METH_O, NULL},
	 { "vectorbdd___len__", _wrap_vectorbdd___len__, METH_O, NULL},
	 { "vectorbdd___getslice__", _wrap_vectorbdd___getslice__, METH_VARARGS, NULL},
	 { "vectorbdd___setslice__", _wrap_vectorbdd___setslice__, METH_VARARGS, NULL},
	 { "vectorbdd___delslice__", _wrap_vectorbdd___delslice__, METH_VARARGS, NULL},
	 { "vectorbdd___delitem__", _wrap_vectorbdd___delitem__, METH_VARARGS, NULL},
	 { "vectorbdd___getitem__", _wrap_vectorbdd___getitem__, METH_VARARGS, NULL},
	 { "vectorbdd___setitem__", _wrap_vectorbdd___setitem__, METH_VARARGS, NULL},
	 { "vectorbdd_pop", _wrap_vectorbdd_pop, METH_O, NULL},
	 { "vectorbdd_append", _wrap_vectorbdd_append, METH_VARARGS, NULL},
	 { "vectorbdd_empty", _wrap_vectorbdd_empty, METH_O, NULL},
	 { "vectorbdd_size", _wrap_vectorbdd_size, METH_O, NULL},
	 { "vectorbdd_swap", _wrap_vectorbdd_swap, METH_VARARGS, NULL},
	 { "vectorbdd_begin", _wrap_vectorbdd_begin, METH_O, NULL},
	 { "vectorbdd_end", _wrap_vectorbdd_end, METH_O, NULL},
	 { "vectorbdd_rbegin", _wrap_vectorbdd_rbegin, METH_O, NULL},
	 { "vectorbdd_rend", _wrap_vectorbdd_rend, METH_O, NULL},
	 { "vectorbdd_clear", _wrap_vectorbdd_clear, METH_O, NULL},
	 { "vectorbdd_get_allocator", _wrap_vectorbdd_get_allocator, METH_O, NULL},
	 { "vectorbdd_pop_back", _wrap_vectorbdd_pop_back, METH_O, NULL},
	 { "vectorbdd_erase", _wrap_vectorbdd_erase, METH_VARARGS, NULL},
	 { "new_vectorbdd", _wrap_new_vectorbdd, METH_VARARGS, NULL},
	 { "vectorbdd_push_back", _wrap_vectorbdd_push_back, METH_VARARGS, NULL},
	 { "vectorbdd_front", _wrap_vectorbdd_front, METH_O, NULL},
	 { "vectorbdd_back", _wrap_vectorbdd_back, METH_O, NULL},
	 { "vectorbdd_assign", _wrap_vectorbdd_assign, METH_VARARGS, NULL},
	 { "vectorbdd_resize", _wrap_vectorbdd_resize, METH_VARARGS, NULL},
	 { "vectorbdd_insert", _wrap_vectorbdd_insert, METH_VARARGS, NULL},
	 { "vectorbdd_reserve", _wrap_vectorbdd_reserve, METH_VARARGS, NULL},
	 { "vectorbdd_capacity", _wrap_vectorbdd_capacity, METH_O, NULL},
	 { "delete_vectorbdd", _wrap_delete_vectorbdd, METH_O, NULL},
	 { "vectorbdd_swigregister", vectorbdd_swigregister, METH_O, NULL},
	 { "vectorbdd_swiginit", vectorbdd_swiginit, METH_VARARGS, NULL},
	 { "aliasvector_iterator", _wrap_aliasvector_iterator, METH_O, NULL},
	 { "aliasvector___nonzero__", _wrap_aliasvector___nonzero__, METH_O, NULL},
	 { "aliasvector___bool__", _wrap_aliasvector___bool__, METH_O, NULL},
	 { "aliasvector___len__", _wrap_aliasvector___len__, METH_O, NULL},
	 { "aliasvector___getslice__", _wrap_aliasvector___getslice__, METH_VARARGS, NULL},
	 { "aliasvector___setslice__", _wrap_aliasvector___setslice__, METH_VARARGS, NULL},
	 { "aliasvector___delslice__", _wrap_aliasvector___delslice__, METH_VARARGS, NULL},
	 { "aliasvector___delitem__", _wrap_aliasvector___delitem__, METH_VARARGS, NULL},
	 { "aliasvector___getitem__", _wrap_aliasvector___getitem__, METH_VARARGS, NULL},
	 { "aliasvector___setitem__", _wrap_aliasvector___setitem__, METH_VARARGS, NULL},
	 { "aliasvector_pop", _wrap_aliasvector_pop, METH_O, NULL},
	 { "aliasvector_append", _wrap_aliasvector_append, METH_VARARGS, NULL},
	 { "aliasvector_empty", _wrap_aliasvector_empty, METH_O, NULL},
	 { "aliasvector_size", _wrap_aliasvector_size, METH_O, NULL},
	 { "aliasvector_swap", _wrap_aliasvector_swap, METH_VARARGS, NULL},
	 { "aliasvector_begin", _wrap_aliasvector_begin, METH_O, NULL},
	 { "aliasvector_end", _wrap_aliasvector_end, METH_O, NULL},
	 { "aliasvector_rbegin", _wrap_aliasvector_rbegin, METH_O, NULL},
	 { "aliasvector_rend", _wrap_aliasvector_rend, METH_O, NULL},
	 { "aliasvector_clear", _wrap_aliasvector_clear, METH_O, NULL},
	 { "aliasvector_get_allocator", _wrap_aliasvector_get_allocator, METH_O, NULL},
	 { "aliasvector_pop_back", _wrap_aliasvector_pop_back, METH_O, NULL},
	 { "aliasvector_erase", _wrap_aliasvector_erase, METH_VARARGS, NULL},
	 { "new_aliasvector", _wrap_new_aliasvector, METH_VARARGS, NULL},
	 { "aliasvector_push_back", _wrap_aliasvector_push_back, METH_VARARGS, NULL},
	 { "aliasvector_front", _wrap_aliasvector_front, METH_O, NULL},
	 { "aliasvector_back", _wrap_aliasvector_back, METH_O, NULL},
	 { "aliasvector_assign", _wrap_aliasvector_assign, METH_VARARGS, NULL},
	 { "aliasvector_resize", _wrap_aliasvector_resize, METH_VARARGS, NULL},
	 { "aliasvector_insert", _wrap_aliasvector_insert, METH_VARARGS, NULL},
	 { "aliasvector_reserve", _wrap_aliasvector_reserve, METH_VARARGS, NULL},
	 { "aliasvector_capacity", _wrap_aliasvector_capacity, METH_O, NULL},
	 { "delete_aliasvector", _wrap_delete_aliasvector, METH_O, NULL},
	 { "aliasvector_swigregister", aliasvector_swigregister, METH_O, NULL},
	 { "aliasvector_swiginit", aliasvector_swiginit, METH_VARARGS, NULL},
	 { "vectorstring_iterator", _wrap_vectorstring_iterator, METH_O, NULL},
	 { "vectorstring___nonzero__", _wrap_vectorstring___nonzero__, METH_O, NULL},
	 { "vectorstring___bool__", _wrap_vectorstring___bool__, METH_O, NULL},
	 { "vectorstring___len__", _wrap_vectorstring___len__, METH_O, NULL},
	 { "vectorstring___getslice__", _wrap_vectorstring___getslice__, METH_VARARGS, NULL},
	 { "vectorstring___setslice__", _wrap_vectorstring___setslice__, METH_VARARGS, NULL},
	 { "vectorstring___delslice__", _wrap_vectorstring___delslice__, METH_VARARGS, NULL},
	 { "vectorstring___delitem__", _wrap_vectorstring___delitem__, METH_VARARGS, NULL},
	 { "vectorstring___getitem__", _wrap_vectorstring___getitem__, METH_VARARGS, NULL},
	 { "vectorstring___setitem__", _wrap_vectorstring___setitem__, METH_VARARGS, NULL},
	 { "vectorstring_pop", _wrap_vectorstring_pop, METH_O, NULL},
	 { "vectorstring_append", _wrap_vectorstring_append, METH_VARARGS, NULL},
	 { "vectorstring_empty", _wrap_vectorstring_empty, METH_O, NULL},
	 { "vectorstring_size", _wrap_vectorstring_size, METH_O, NULL},
	 { "vectorstring_swap", _wrap_vectorstring_swap, METH_VARARGS, NULL},
	 { "vectorstring_begin", _wrap_vectorstring_begin, METH_O, NULL},
	 { "vectorstring_end", _wrap_vectorstring_end, METH_O, NULL},
	 { "vectorstring_rbegin", _wrap_vectorstring_rbegin, METH_O, NULL},
	 { "vectorstring_rend", _wrap_vectorstring_rend, METH_O, NULL},
	 { "vectorstring_clear", _wrap_vectorstring_clear, METH_O, NULL},
	 { "vectorstring_get_allocator", _wrap_vectorstring_get_allocator, METH_O, NULL},
	 { "vectorstring_pop_back", _wrap_vectorstring_pop_back, METH_O, NULL},
	 { "vectorstring_erase", _wrap_vectorstring_erase, METH_VARARGS, NULL},
	 { "new_vectorstring", _wrap_new_vectorstring, METH_VARARGS, NULL},
	 { "vectorstring_push_back", _wrap_vectorstring_push_back, METH_VARARGS, NULL},
	 { "vectorstring_front", _wrap_vectorstring_front, METH_O, NULL},
	 { "vectorstring_back", _wrap_vectorstring_back, METH_O, NULL},
	 { "vectorstring_assign", _wrap_vectorstring_assign, METH_VARARGS, NULL},
	 { "vectorstring_resize", _wrap_vectorstring_resize, METH_VARARGS, NULL},
	 { "vectorstring_insert", _wrap_vectorstring_insert, METH_VARARGS, NULL},
	 { "vectorstring_reserve", _wrap_vectorstring_reserve, METH_VARARGS, NULL},
	 { "vectorstring_capacity", _wrap_vectorstring_capacity, METH_O, NULL},
	 { "delete_vectorstring", _wrap_delete_vectorstring, METH_O, NULL},
	 { "vectorstring_swigregister", vectorstring_swigregister, METH_O, NULL},
	 { "vectorstring_swiginit", vectorstring_swiginit, METH_VARARGS, NULL},
	 { "vectorint_iterator", _wrap_vectorint_iterator, METH_O, NULL},
	 { "vectorint___nonzero__", _wrap_vectorint___nonzero__, METH_O, NULL},
	 { "vectorint___bool__", _wrap_vectorint___bool__, METH_O, NULL},
	 { "vectorint___len__", _wrap_vectorint___len__, METH_O, NULL},
	 { "vectorint___getslice__", _wrap_vectorint___getslice__, METH_VARARGS, NULL},
	 { "vectorint___setslice__", _wrap_vectorint___setslice__, METH_VARARGS, NULL},
	 { "vectorint___delslice__", _wrap_vectorint___delslice__, METH_VARARGS, NULL},
	 { "vectorint___delitem__", _wrap_vectorint___delitem__, METH_VARARGS, NULL},
	 { "vectorint___getitem__", _wrap_vectorint___getitem__, METH_VARARGS, NULL},
	 { "vectorint___setitem__", _wrap_vectorint___setitem__, METH_VARARGS, NULL},
	 { "vectorint_pop", _wrap_vectorint_pop, METH_O, NULL},
	 { "vectorint_append", _wrap_vectorint_append, METH_VARARGS, NULL},
	 { "vectorint_empty", _wrap_vectorint_empty, METH_O, NULL},
	 { "vectorint_size", _wrap_vectorint_size, METH_O, NULL},
	 { "vectorint_swap", _wrap_vectorint_swap, METH_VARARGS, NULL},
	 { "vectorint_begin", _wrap_vectorint_begin, METH_O, NULL},
	 { "vectorint_end", _wrap_vectorint_end, METH_O, NULL},
	 { "vectorint_rbegin", _wrap_vectorint_rbegin, METH_O, NULL},
	 { "vectorint_rend", _wrap_vectorint_rend, METH_O, NULL},
	 { "vectorint_clear", _wrap_vectorint_clear, METH_O, NULL},
	 { "vectorint_get_allocator", _wrap_vectorint_get_allocator, METH_O, NULL},
	 { "vectorint_pop_back", _wrap_vectorint_pop_back, METH_O, NULL},
	 { "vectorint_erase", _wrap_vectorint_erase, METH_VARARGS, NULL},
	 { "new_vectorint", _wrap_new_vectorint, METH_VARARGS, NULL},
	 { "vectorint_push_back", _wrap_vectorint_push_back, METH_VARARGS, NULL},
	 { "vectorint_front", _wrap_vectorint_front, METH_O, NULL},
	 { "vectorint_back", _wrap_vectorint_back, METH_O, NULL},
	 { "vectorint_assign", _wrap_vectorint_assign, METH_VARARGS, NULL},
	 { "vectorint_resize", _wrap_vectorint_resize, METH_VARARGS, NULL},
	 { "vectorint_insert", _wrap_vectorint_insert, METH_VARARGS, NULL},
	 { "vectorint_reserve", _wrap_vectorint_reserve, METH_VARARGS, NULL},
	 { "vectorint_capacity", _wrap_vectorint_capacity, METH_O, NULL},
	 { "delete_vectorint", _wrap_delete_vectorint, METH_O, NULL},
	 { "vectorint_swigregister", vectorint_swigregister, METH_O, NULL},
	 { "vectorint_swiginit", vectorint_swiginit, METH_VARARGS, NULL},
	 { "new_pair_formula_vectorstring", _wrap_new_pair_formula_vectorstring, METH_VARARGS, NULL},
	 { "pair_formula_vectorstring_first_set", _wrap_pair_formula_vectorstring_first_set, METH_VARARGS, NULL},
	 { "pair_formula_vectorstring_first_get", _wrap_pair_formula_vectorstring_first_get, METH_O, NULL},
	 { "pair_formula_vectorstring_second_set", _wrap_pair_formula_vectorstring_second_set, METH_VARARGS, NULL},
	 { "pair_formula_vectorstring_second_get", _wrap_pair_formula_vectorstring_second_get, METH_O, NULL},
	 { "delete_pair_formula_vectorstring", _wrap_delete_pair_formula_vectorstring, METH_O, NULL},
	 { "pair_formula_vectorstring_swigregister", pair_formula_vectorstring_swigregister, METH_O, NULL},
	 { "pair_formula_vectorstring_swiginit", pair_formula_vectorstring_swiginit, METH_VARARGS, NULL},
	 { "atomic_prop_set_iterator", _wrap_atomic_prop_set_iterator, METH_O, NULL},
	 { "atomic_prop_set___nonzero__", _wrap_atomic_prop_set___nonzero__, METH_O, NULL},
	 { "atomic_prop_set___bool__", _wrap_atomic_prop_set___bool__, METH_O, NULL},
	 { "atomic_prop_set___len__", _wrap_atomic_prop_set___len__, METH_O, NULL},
	 { "atomic_prop_set_append", _wrap_atomic_prop_set_append, METH_VARARGS, NULL},
	 { "atomic_prop_set___contains__", _wrap_atomic_prop_set___contains__, METH_VARARGS, NULL},
	 { "atomic_prop_set___getitem__", _wrap_atomic_prop_set___getitem__, METH_VARARGS, NULL},
	 { "atomic_prop_set_add", _wrap_atomic_prop_set_add, METH_VARARGS, NULL},
	 { "atomic_prop_set_discard", _wrap_atomic_prop_set_discard, METH_VARARGS, NULL},
	 { "new_atomic_prop_set", _wrap_new_atomic_prop_set, METH_VARARGS, NULL},
	 { "atomic_prop_set_empty", _wrap_atomic_prop_set_empty, METH_O, NULL},
	 { "atomic_prop_set_size", _wrap_atomic_prop_set_size, METH_O, NULL},
	 { "atomic_prop_set_clear", _wrap_atomic_prop_set_clear, METH_O, NULL},
	 { "atomic_prop_set_swap", _wrap_atomic_prop_set_swap, METH_VARARGS, NULL},
	 { "atomic_prop_set_count", _wrap_atomic_prop_set_count, METH_VARARGS, NULL},
	 { "atomic_prop_set_begin", _wrap_atomic_prop_set_begin, METH_O, NULL},
	 { "atomic_prop_set_end", _wrap_atomic_prop_set_end, METH_O, NULL},
	 { "atomic_prop_set_rbegin", _wrap_atomic_prop_set_rbegin, METH_O, NULL},
	 { "atomic_prop_set_rend", _wrap_atomic_prop_set_rend, METH_O, NULL},
	 { "atomic_prop_set_erase", _wrap_atomic_prop_set_erase, METH_VARARGS, NULL},
	 { "atomic_prop_set_find", _wrap_atomic_prop_set_find, METH_VARARGS, NULL},
	 { "atomic_prop_set_lower_bound", _wrap_atomic_prop_set_lower_bound, METH_VARARGS, NULL},
	 { "atomic_prop_set_upper_bound", _wrap_atomic_prop_set_upper_bound, METH_VARARGS, NULL},
	 { "atomic_prop_set_equal_range", _wrap_atomic_prop_set_equal_range, METH_VARARGS, NULL},
	 { "atomic_prop_set_insert", _wrap_atomic_prop_set_insert, METH_VARARGS, NULL},
	 { "atomic_prop_set___str__", _wrap_atomic_prop_set___str__, METH_O, NULL},
	 { "atomic_prop_set___repr__", _wrap_atomic_prop_set___repr__, METH_O, NULL},
	 { "delete_atomic_prop_set", _wrap_delete_atomic_prop_set, METH_O, NULL},
	 { "atomic_prop_set_swigregister", atomic_prop_set_swigregister, METH_O, NULL},
	 { "atomic_prop_set_swiginit", atomic_prop_set_swiginit, METH_VARARGS, NULL},
	 { "relabeling_map_iterator", _wrap_relabeling_map_iterator, METH_O, NULL},
	 { "relabeling_map___nonzero__", _wrap_relabeling_map___nonzero__, METH_O, NULL},
	 { "relabeling_map___bool__", _wrap_relabeling_map___bool__, METH_O, NULL},
	 { "relabeling_map___len__", _wrap_relabeling_map___len__, METH_O, NULL},
	 { "relabeling_map___getitem__", _wrap_relabeling_map___getitem__, METH_VARARGS, NULL},
	 { "relabeling_map___delitem__", _wrap_relabeling_map___delitem__, METH_VARARGS, NULL},
	 { "relabeling_map_has_key", _wrap_relabeling_map_has_key, METH_VARARGS, NULL},
	 { "relabeling_map_keys", _wrap_relabeling_map_keys, METH_O, NULL},
	 { "relabeling_map_values", _wrap_relabeling_map_values, METH_O, NULL},
	 { "relabeling_map_items", _wrap_relabeling_map_items, METH_O, NULL},
	 { "relabeling_map___contains__", _wrap_relabeling_map___contains__, METH_VARARGS, NULL},
	 { "relabeling_map_key_iterator", _wrap_relabeling_map_key_iterator, METH_O, NULL},
	 { "relabeling_map_value_iterator", _wrap_relabeling_map_value_iterator, METH_O, NULL},
	 { "relabeling_map___setitem__", _wrap_relabeling_map___setitem__, METH_VARARGS, NULL},
	 { "relabeling_map_asdict", _wrap_relabeling_map_asdict, METH_O, NULL},
	 { "new_relabeling_map", _wrap_new_relabeling_map, METH_VARARGS, NULL},
	 { "relabeling_map_empty", _wrap_relabeling_map_empty, METH_O, NULL},
	 { "relabeling_map_size", _wrap_relabeling_map_size, METH_O, NULL},
	 { "relabeling_map_swap", _wrap_relabeling_map_swap, METH_VARARGS, NULL},
	 { "relabeling_map_begin", _wrap_relabeling_map_begin, METH_O, NULL},
	 { "relabeling_map_end", _wrap_relabeling_map_end, METH_O, NULL},
	 { "relabeling_map_rbegin", _wrap_relabeling_map_rbegin, METH_O, NULL},
	 { "relabeling_map_rend", _wrap_relabeling_map_rend, METH_O, NULL},
	 { "relabeling_map_clear", _wrap_relabeling_map_clear, METH_O, NULL},
	 { "relabeling_map_get_allocator", _wrap_relabeling_map_get_allocator, METH_O, NULL},
	 { "relabeling_map_count", _wrap_relabeling_map_count, METH_VARARGS, NULL},
	 { "relabeling_map_erase", _wrap_relabeling_map_erase, METH_VARARGS, NULL},
	 { "relabeling_map_find", _wrap_relabeling_map_find, METH_VARARGS, NULL},
	 { "relabeling_map_lower_bound", _wrap_relabeling_map_lower_bound, METH_VARARGS, NULL},
	 { "relabeling_map_upper_bound", _wrap_relabeling_map_upper_bound, METH_VARARGS, NULL},
	 { "delete_relabeling_map", _wrap_delete_relabeling_map, METH_O, NULL},
	 { "relabeling_map_swigregister", relabeling_map_swigregister, METH_O, NULL},
	 { "relabeling_map_swiginit", relabeling_map_swiginit, METH_VARARGS, NULL},
	 { "environment_require", _wrap_environment_require, METH_VARARGS, NULL},
	 { "environment_name", _wrap_environment_name, METH_O, NULL},
	 { "delete_environment", _wrap_delete_environment, METH_O, NULL},
	 { "environment_swigregister", environment_swigregister, METH_O, NULL},
	 { "new_declarative_environment", _wrap_new_declarative_environment, METH_NOARGS, NULL},
	 { "delete_declarative_environment", _wrap_delete_declarative_environment, METH_O, NULL},
	 { "declarative_environment_declare", _wrap_declarative_environment_declare, METH_VARARGS, NULL},
	 { "declarative_environment_get_prop_map", _wrap_declarative_environment_get_prop_map, METH_O, NULL},
	 { "declarative_environment_swigregister", declarative_environment_swigregister, METH_O, NULL},
	 { "declarative_environment_swiginit", declarative_environment_swiginit, METH_VARARGS, NULL},
	 { "delete_default_environment", _wrap_delete_default_environment, METH_O, NULL},
	 { "default_environment_instance", _wrap_default_environment_instance, METH_NOARGS, NULL},
	 { "default_environment_swigregister", default_environment_swigregister, METH_O, NULL},
	 { "parse_error_list___nonzero__", _wrap_parse_error_list___nonzero__, METH_O, NULL},
	 { "parse_error_list___bool__", _wrap_parse_error_list___bool__, METH_O, NULL},
	 { "new_parse_error_list", _wrap_new_parse_error_list, METH_NOARGS, NULL},
	 { "delete_parse_error_list", _wrap_delete_parse_error_list, METH_O, NULL},
	 { "parse_error_list_swigregister", parse_error_list_swigregister, METH_O, NULL},
	 { "parse_error_list_swiginit", parse_error_list_swiginit, METH_VARARGS, NULL},
	 { "parsed_formula_f_set", _wrap_parsed_formula_f_set, METH_VARARGS, NULL},
	 { "parsed_formula_f_get", _wrap_parsed_formula_f_get, METH_O, NULL},
	 { "parsed_formula_input_set", _wrap_parsed_formula_input_set, METH_VARARGS, NULL},
	 { "parsed_formula_input_get", _wrap_parsed_formula_input_get, METH_O, NULL},
	 { "parsed_formula_errors_set", _wrap_parsed_formula_errors_set, METH_VARARGS, NULL},
	 { "parsed_formula_errors_get", _wrap_parsed_formula_errors_get, METH_O, NULL},
	 { "new_parsed_formula", _wrap_new_parsed_formula, METH_VARARGS, NULL},
	 { "parsed_formula_format_errors", _wrap_parsed_formula_format_errors, METH_VARARGS, NULL},
	 { "delete_parsed_formula", _wrap_delete_parsed_formula, METH_O, NULL},
	 { "parsed_formula_swigregister", parsed_formula_swigregister, METH_O, NULL},
	 { "parsed_formula_swiginit", parsed_formula_swiginit, METH_VARARGS, NULL},
	 { "parse_infix_psl", _wrap_parse_infix_psl, METH_VARARGS, NULL},
	 { "parse_infix_boolean", _wrap_parse_infix_boolean, METH_VARARGS, NULL},
	 { "parse_prefix_ltl", _wrap_parse_prefix_ltl, METH_VARARGS, NULL},
	 { "parse_formula", _wrap_parse_formula, METH_VARARGS, NULL},
	 { "parse_infix_sere", _wrap_parse_infix_sere, METH_VARARGS, NULL},
	 { "fix_utf8_locations", _wrap_fix_utf8_locations, METH_VARARGS, NULL},
	 { "new_bdd_dict", _wrap_new_bdd_dict, METH_NOARGS, NULL},
	 { "delete_bdd_dict", _wrap_delete_bdd_dict, METH_O, NULL},
	 { "bdd_dict_var_map_set", _wrap_bdd_dict_var_map_set, METH_VARARGS, NULL},
	 { "bdd_dict_var_map_get", _wrap_bdd_dict_var_map_get, METH_O, NULL},
	 { "bdd_dict_acc_map_set", _wrap_bdd_dict_acc_map_set, METH_VARARGS, NULL},
	 { "bdd_dict_acc_map_get", _wrap_bdd_dict_acc_map_get, METH_O, NULL},
	 { "bdd_dict_bdd_map_set", _wrap_bdd_dict_bdd_map_set, METH_VARARGS, NULL},
	 { "bdd_dict_bdd_map_get", _wrap_bdd_dict_bdd_map_get, METH_O, NULL},
	 { "bdd_dict_has_registered_proposition", _wrap_bdd_dict_has_registered_proposition, METH_VARARGS, NULL},
	 { "bdd_dict_varnum", _wrap_bdd_dict_varnum, METH_VARARGS, NULL},
	 { "bdd_dict_register_acceptance_variable", _wrap_bdd_dict_register_acceptance_variable, METH_VARARGS, NULL},
	 { "bdd_dict_dump", _wrap_bdd_dict_dump, METH_VARARGS, NULL},
	 { "bdd_dict_assert_emptiness", _wrap_bdd_dict_assert_emptiness, METH_O, NULL},
	 { "bdd_dict___eq__", _wrap_bdd_dict___eq__, METH_VARARGS, NULL},
	 { "bdd_dict___ne__", _wrap_bdd_dict___ne__, METH_VARARGS, NULL},
	 { "bdd_dict_register_proposition", _wrap_bdd_dict_register_proposition, METH_VARARGS, NULL},
	 { "bdd_dict_unregister_all_my_variables", _wrap_bdd_dict_unregister_all_my_variables, METH_VARARGS, NULL},
	 { "bdd_dict_unregister_variable", _wrap_bdd_dict_unregister_variable, METH_VARARGS, NULL},
	 { "bdd_dict_register_all_variables_of", _wrap_bdd_dict_register_all_variables_of, METH_VARARGS, NULL},
	 { "bdd_dict_register_anonymous_variables", _wrap_bdd_dict_register_anonymous_variables, METH_VARARGS, NULL},
	 { "bdd_dict_swigregister", bdd_dict_swigregister, METH_O, NULL},
	 { "bdd_dict_swiginit", bdd_dict_swiginit, METH_VARARGS, NULL},
	 { "make_bdd_dict", _wrap_make_bdd_dict, METH_NOARGS, NULL},
	 { "bdd_print_sat", _wrap_bdd_print_sat, METH_VARARGS, NULL},
	 { "bdd_format_sat", _wrap_bdd_format_sat, METH_VARARGS, NULL},
	 { "bdd_print_accset", _wrap_bdd_print_accset, METH_VARARGS, NULL},
	 { "bdd_format_accset", _wrap_bdd_format_accset, METH_VARARGS, NULL},
	 { "bdd_print_set", _wrap_bdd_print_set, METH_VARARGS, NULL},
	 { "bdd_format_set", _wrap_bdd_format_set, METH_VARARGS, NULL},
	 { "bdd_print_formula", _wrap_bdd_print_formula, METH_VARARGS, NULL},
	 { "bdd_format_formula", _wrap_bdd_format_formula, METH_VARARGS, NULL},
	 { "enable_utf8", _wrap_enable_utf8, METH_NOARGS, NULL},
	 { "bdd_format_isop", _wrap_bdd_format_isop, METH_VARARGS, NULL},
	 { "bdd_print_isop", _wrap_bdd_print_isop, METH_VARARGS, NULL},
	 { "bdd_to_formula", _wrap_bdd_to_formula, METH_VARARGS, NULL},
	 { "formula_to_bdd", _wrap_formula_to_bdd, METH_VARARGS, NULL},
	 { "vector_rs_pair_iterator", _wrap_vector_rs_pair_iterator, METH_O, NULL},
	 { "vector_rs_pair___nonzero__", _wrap_vector_rs_pair___nonzero__, METH_O, NULL},
	 { "vector_rs_pair___bool__", _wrap_vector_rs_pair___bool__, METH_O, NULL},
	 { "vector_rs_pair___len__", _wrap_vector_rs_pair___len__, METH_O, NULL},
	 { "vector_rs_pair___getslice__", _wrap_vector_rs_pair___getslice__, METH_VARARGS, NULL},
	 { "vector_rs_pair___setslice__", _wrap_vector_rs_pair___setslice__, METH_VARARGS, NULL},
	 { "vector_rs_pair___delslice__", _wrap_vector_rs_pair___delslice__, METH_VARARGS, NULL},
	 { "vector_rs_pair___delitem__", _wrap_vector_rs_pair___delitem__, METH_VARARGS, NULL},
	 { "vector_rs_pair___getitem__", _wrap_vector_rs_pair___getitem__, METH_VARARGS, NULL},
	 { "vector_rs_pair___setitem__", _wrap_vector_rs_pair___setitem__, METH_VARARGS, NULL},
	 { "vector_rs_pair_pop", _wrap_vector_rs_pair_pop, METH_O, NULL},
	 { "vector_rs_pair_append", _wrap_vector_rs_pair_append, METH_VARARGS, NULL},
	 { "vector_rs_pair_empty", _wrap_vector_rs_pair_empty, METH_O, NULL},
	 { "vector_rs_pair_size", _wrap_vector_rs_pair_size, METH_O, NULL},
	 { "vector_rs_pair_swap", _wrap_vector_rs_pair_swap, METH_VARARGS, NULL},
	 { "vector_rs_pair_begin", _wrap_vector_rs_pair_begin, METH_O, NULL},
	 { "vector_rs_pair_end", _wrap_vector_rs_pair_end, METH_O, NULL},
	 { "vector_rs_pair_rbegin", _wrap_vector_rs_pair_rbegin, METH_O, NULL},
	 { "vector_rs_pair_rend", _wrap_vector_rs_pair_rend, METH_O, NULL},
	 { "vector_rs_pair_clear", _wrap_vector_rs_pair_clear, METH_O, NULL},
	 { "vector_rs_pair_get_allocator", _wrap_vector_rs_pair_get_allocator, METH_O, NULL},
	 { "vector_rs_pair_pop_back", _wrap_vector_rs_pair_pop_back, METH_O, NULL},
	 { "vector_rs_pair_erase", _wrap_vector_rs_pair_erase, METH_VARARGS, NULL},
	 { "new_vector_rs_pair", _wrap_new_vector_rs_pair, METH_VARARGS, NULL},
	 { "vector_rs_pair_push_back", _wrap_vector_rs_pair_push_back, METH_VARARGS, NULL},
	 { "vector_rs_pair_front", _wrap_vector_rs_pair_front, METH_O, NULL},
	 { "vector_rs_pair_back", _wrap_vector_rs_pair_back, METH_O, NULL},
	 { "vector_rs_pair_assign", _wrap_vector_rs_pair_assign, METH_VARARGS, NULL},
	 { "vector_rs_pair_resize", _wrap_vector_rs_pair_resize, METH_VARARGS, NULL},
	 { "vector_rs_pair_insert", _wrap_vector_rs_pair_insert, METH_VARARGS, NULL},
	 { "vector_rs_pair_reserve", _wrap_vector_rs_pair_reserve, METH_VARARGS, NULL},
	 { "vector_rs_pair_capacity", _wrap_vector_rs_pair_capacity, METH_O, NULL},
	 { "delete_vector_rs_pair", _wrap_delete_vector_rs_pair, METH_O, NULL},
	 { "vector_rs_pair_swigregister", vector_rs_pair_swigregister, METH_O, NULL},
	 { "vector_rs_pair_swiginit", vector_rs_pair_swiginit, METH_VARARGS, NULL},
	 { "acc_cond_has_parity_prefix", _wrap_acc_cond_has_parity_prefix, METH_VARARGS, NULL},
	 { "new_acc_cond", _wrap_new_acc_cond, METH_VARARGS, NULL},
	 { "delete_acc_cond", _wrap_delete_acc_cond, METH_O, NULL},
	 { "acc_cond_set_acceptance", _wrap_acc_cond_set_acceptance, METH_VARARGS, NULL},
	 { "acc_cond_get_acceptance", _wrap_acc_cond_get_acceptance, METH_VARARGS, NULL},
	 { "acc_cond___eq__", _wrap_acc_cond___eq__, METH_VARARGS, NULL},
	 { "acc_cond___ne__", _wrap_acc_cond___ne__, METH_VARARGS, NULL},
	 { "acc_cond_uses_fin_acceptance", _wrap_acc_cond_uses_fin_acceptance, METH_O, NULL},
	 { "acc_cond_is_t", _wrap_acc_cond_is_t, METH_O, NULL},
	 { "acc_cond_is_all", _wrap_acc_cond_is_all, METH_O, NULL},
	 { "acc_cond_is_f", _wrap_acc_cond_is_f, METH_O, NULL},
	 { "acc_cond_is_none", _wrap_acc_cond_is_none, METH_O, NULL},
	 { "acc_cond_is_buchi", _wrap_acc_cond_is_buchi, METH_O, NULL},
	 { "acc_cond_is_co_buchi", _wrap_acc_cond_is_co_buchi, METH_O, NULL},
	 { "acc_cond_set_generalized_buchi", _wrap_acc_cond_set_generalized_buchi, METH_O, NULL},
	 { "acc_cond_set_generalized_co_buchi", _wrap_acc_cond_set_generalized_co_buchi, METH_O, NULL},
	 { "acc_cond_is_generalized_buchi", _wrap_acc_cond_is_generalized_buchi, METH_O, NULL},
	 { "acc_cond_is_generalized_co_buchi", _wrap_acc_cond_is_generalized_co_buchi, METH_O, NULL},
	 { "acc_cond_is_rabin", _wrap_acc_cond_is_rabin, METH_O, NULL},
	 { "acc_cond_is_streett", _wrap_acc_cond_is_streett, METH_O, NULL},
	 { "acc_cond_is_streett_like", _wrap_acc_cond_is_streett_like, METH_O, NULL},
	 { "acc_cond_is_rabin_like", _wrap_acc_cond_is_rabin_like, METH_O, NULL},
	 { "acc_cond_is_generalized_rabin", _wrap_acc_cond_is_generalized_rabin, METH_O, NULL},
	 { "acc_cond_is_generalized_streett", _wrap_acc_cond_is_generalized_streett, METH_O, NULL},
	 { "acc_cond_is_parity_max_equiv", _wrap_acc_cond_is_parity_max_equiv, METH_VARARGS, NULL},
	 { "acc_cond_is_parity", _wrap_acc_cond_is_parity, METH_VARARGS, NULL},
	 { "acc_cond_unit_propagation", _wrap_acc_cond_unit_propagation, METH_O, NULL},
	 { "acc_cond_unsat_mark", _wrap_acc_cond_unsat_mark, METH_O, NULL},
	 { "acc_cond_sat_mark", _wrap_acc_cond_sat_mark, METH_O, NULL},
	 { "acc_cond_inf", _wrap_acc_cond_inf, METH_VARARGS, NULL},
	 { "acc_cond_inf_neg", _wrap_acc_cond_inf_neg, METH_VARARGS, NULL},
	 { "acc_cond_fin", _wrap_acc_cond_fin, METH_VARARGS, NULL},
	 { "acc_cond_fin_neg", _wrap_acc_cond_fin_neg, METH_VARARGS, NULL},
	 { "acc_cond_add_sets", _wrap_acc_cond_add_sets, METH_VARARGS, NULL},
	 { "acc_cond_add_set", _wrap_acc_cond_add_set, METH_O, NULL},
	 { "acc_cond_mark", _wrap_acc_cond_mark, METH_VARARGS, NULL},
	 { "acc_cond_comp", _wrap_acc_cond_comp, METH_VARARGS, NULL},
	 { "acc_cond_all_sets", _wrap_acc_cond_all_sets, METH_O, NULL},
	 { "acc_cond_apply_permutation", _wrap_acc_cond_apply_permutation, METH_VARARGS, NULL},
	 { "acc_cond_apply_permutation_aux", _wrap_acc_cond_apply_permutation_aux, METH_VARARGS, NULL},
	 { "acc_cond_accepting", _wrap_acc_cond_accepting, METH_VARARGS, NULL},
	 { "acc_cond_inf_satisfiable", _wrap_acc_cond_inf_satisfiable, METH_VARARGS, NULL},
	 { "acc_cond_maybe_accepting", _wrap_acc_cond_maybe_accepting, METH_VARARGS, NULL},
	 { "acc_cond_accepting_sets", _wrap_acc_cond_accepting_sets, METH_VARARGS, NULL},
	 { "acc_cond_format", _wrap_acc_cond_format, METH_VARARGS, NULL},
	 { "acc_cond_num_sets", _wrap_acc_cond_num_sets, METH_O, NULL},
	 { "acc_cond_remove", _wrap_acc_cond_remove, METH_VARARGS, NULL},
	 { "acc_cond_strip", _wrap_acc_cond_strip, METH_VARARGS, NULL},
	 { "acc_cond_force_inf", _wrap_acc_cond_force_inf, METH_VARARGS, NULL},
	 { "acc_cond_restrict_to", _wrap_acc_cond_restrict_to, METH_VARARGS, NULL},
	 { "acc_cond_name", _wrap_acc_cond_name, METH_VARARGS, NULL},
	 { "acc_cond_fin_unit", _wrap_acc_cond_fin_unit, METH_O, NULL},
	 { "acc_cond_inf_unit", _wrap_acc_cond_inf_unit, METH_O, NULL},
	 { "acc_cond_fin_one", _wrap_acc_cond_fin_one, METH_O, NULL},
	 { "acc_cond_fin_one_extract", _wrap_acc_cond_fin_one_extract, METH_O, NULL},
	 { "acc_cond_fin_unit_one_split", _wrap_acc_cond_fin_unit_one_split, METH_O, NULL},
	 { "acc_cond_top_disjuncts", _wrap_acc_cond_top_disjuncts, METH_O, NULL},
	 { "acc_cond_top_conjuncts", _wrap_acc_cond_top_conjuncts, METH_O, NULL},
	 { "acc_cond___repr__", _wrap_acc_cond___repr__, METH_O, NULL},
	 { "acc_cond___str__", _wrap_acc_cond___str__, METH_O, NULL},
	 { "acc_cond_swigregister", acc_cond_swigregister, METH_O, NULL},
	 { "acc_cond_swiginit", acc_cond_swiginit, METH_VARARGS, NULL},
	 { "mark_t_apply_permutation", _wrap_mark_t_apply_permutation, METH_VARARGS, NULL},
	 { "mark_t_max_accsets", _wrap_mark_t_max_accsets, METH_NOARGS, NULL},
	 { "mark_t_all", _wrap_mark_t_all, METH_NOARGS, NULL},
	 { "mark_t_hash", _wrap_mark_t_hash, METH_O, NULL},
	 { "mark_t___eq__", _wrap_mark_t___eq__, METH_VARARGS, NULL},
	 { "mark_t___ne__", _wrap_mark_t___ne__, METH_VARARGS, NULL},
	 { "mark_t___lt__", _wrap_mark_t___lt__, METH_VARARGS, NULL},
	 { "mark_t___le__", _wrap_mark_t___le__, METH_VARARGS, NULL},
	 { "mark_t___gt__", _wrap_mark_t___gt__, METH_VARARGS, NULL},
	 { "mark_t___ge__", _wrap_mark_t___ge__, METH_VARARGS, NULL},
	 { "mark_t___nonzero__", _wrap_mark_t___nonzero__, METH_O, NULL},
	 { "mark_t_has", _wrap_mark_t_has, METH_VARARGS, NULL},
	 { "mark_t_set", _wrap_mark_t_set, METH_VARARGS, NULL},
	 { "mark_t_clear", _wrap_mark_t_clear, METH_VARARGS, NULL},
	 { "mark_t___iand__", _wrap_mark_t___iand__, METH_VARARGS, NULL},
	 { "mark_t___ior__", _wrap_mark_t___ior__, METH_VARARGS, NULL},
	 { "mark_t___isub__", _wrap_mark_t___isub__, METH_VARARGS, NULL},
	 { "mark_t___ixor__", _wrap_mark_t___ixor__, METH_VARARGS, NULL},
	 { "mark_t___and__", _wrap_mark_t___and__, METH_VARARGS, NULL},
	 { "mark_t___or__", _wrap_mark_t___or__, METH_VARARGS, NULL},
	 { "mark_t___sub__", _wrap_mark_t___sub__, METH_VARARGS, NULL},
	 { "mark_t___invert__", _wrap_mark_t___invert__, METH_O, NULL},
	 { "mark_t___xor__", _wrap_mark_t___xor__, METH_VARARGS, NULL},
	 { "mark_t___lshift__", _wrap_mark_t___lshift__, METH_VARARGS, NULL},
	 { "mark_t___ilshift__", _wrap_mark_t___ilshift__, METH_VARARGS, NULL},
	 { "mark_t___rshift__", _wrap_mark_t___rshift__, METH_VARARGS, NULL},
	 { "mark_t___irshift__", _wrap_mark_t___irshift__, METH_VARARGS, NULL},
	 { "mark_t_strip", _wrap_mark_t_strip, METH_VARARGS, NULL},
	 { "mark_t_subset", _wrap_mark_t_subset, METH_VARARGS, NULL},
	 { "mark_t_proper_subset", _wrap_mark_t_proper_subset, METH_VARARGS, NULL},
	 { "mark_t_count", _wrap_mark_t_count, METH_O, NULL},
	 { "mark_t_max_set", _wrap_mark_t_max_set, METH_O, NULL},
	 { "mark_t_min_set", _wrap_mark_t_min_set, METH_O, NULL},
	 { "mark_t_lowest", _wrap_mark_t_lowest, METH_O, NULL},
	 { "mark_t_is_singleton", _wrap_mark_t_is_singleton, METH_O, NULL},
	 { "mark_t_has_many", _wrap_mark_t_has_many, METH_O, NULL},
	 { "mark_t_remove_some", _wrap_mark_t_remove_some, METH_VARARGS, NULL},
	 { "mark_t_sets", _wrap_mark_t_sets, METH_O, NULL},
	 { "mark_t_as_string", _wrap_mark_t_as_string, METH_O, NULL},
	 { "new_mark_t", _wrap_new_mark_t, METH_VARARGS, NULL},
	 { "mark_t___repr__", _wrap_mark_t___repr__, METH_O, NULL},
	 { "mark_t___str__", _wrap_mark_t___str__, METH_O, NULL},
	 { "delete_mark_t", _wrap_delete_mark_t, METH_O, NULL},
	 { "mark_t_swigregister", mark_t_swigregister, METH_O, NULL},
	 { "mark_t_swiginit", mark_t_swiginit, METH_VARARGS, NULL},
	 { "acc_code_unit_propagation", _wrap_acc_code_unit_propagation, METH_O, NULL},
	 { "acc_code_has_parity_prefix", _wrap_acc_code_has_parity_prefix, METH_VARARGS, NULL},
	 { "acc_code_is_parity_max_equiv", _wrap_acc_code_is_parity_max_equiv, METH_VARARGS, NULL},
	 { "acc_code___eq__", _wrap_acc_code___eq__, METH_VARARGS, NULL},
	 { "acc_code___lt__", _wrap_acc_code___lt__, METH_VARARGS, NULL},
	 { "acc_code___gt__", _wrap_acc_code___gt__, METH_VARARGS, NULL},
	 { "acc_code___le__", _wrap_acc_code___le__, METH_VARARGS, NULL},
	 { "acc_code___ge__", _wrap_acc_code___ge__, METH_VARARGS, NULL},
	 { "acc_code___ne__", _wrap_acc_code___ne__, METH_VARARGS, NULL},
	 { "acc_code_is_t", _wrap_acc_code_is_t, METH_O, NULL},
	 { "acc_code_is_f", _wrap_acc_code_is_f, METH_O, NULL},
	 { "acc_code_f", _wrap_acc_code_f, METH_NOARGS, NULL},
	 { "acc_code_t", _wrap_acc_code_t, METH_NOARGS, NULL},
	 { "acc_code_fin", _wrap_acc_code_fin, METH_VARARGS, NULL},
	 { "acc_code_fin_neg", _wrap_acc_code_fin_neg, METH_VARARGS, NULL},
	 { "acc_code_inf", _wrap_acc_code_inf, METH_VARARGS, NULL},
	 { "acc_code_inf_neg", _wrap_acc_code_inf_neg, METH_VARARGS, NULL},
	 { "acc_code_buchi", _wrap_acc_code_buchi, METH_NOARGS, NULL},
	 { "acc_code_cobuchi", _wrap_acc_code_cobuchi, METH_NOARGS, NULL},
	 { "acc_code_generalized_buchi", _wrap_acc_code_generalized_buchi, METH_O, NULL},
	 { "acc_code_generalized_co_buchi", _wrap_acc_code_generalized_co_buchi, METH_O, NULL},
	 { "acc_code_rabin", _wrap_acc_code_rabin, METH_O, NULL},
	 { "acc_code_streett", _wrap_acc_code_streett, METH_O, NULL},
	 { "acc_code_parity", _wrap_acc_code_parity, METH_VARARGS, NULL},
	 { "acc_code_parity_max", _wrap_acc_code_parity_max, METH_VARARGS, NULL},
	 { "acc_code_parity_max_odd", _wrap_acc_code_parity_max_odd, METH_O, NULL},
	 { "acc_code_parity_max_even", _wrap_acc_code_parity_max_even, METH_O, NULL},
	 { "acc_code_parity_min", _wrap_acc_code_parity_min, METH_VARARGS, NULL},
	 { "acc_code_parity_min_odd", _wrap_acc_code_parity_min_odd, METH_O, NULL},
	 { "acc_code_parity_min_even", _wrap_acc_code_parity_min_even, METH_O, NULL},
	 { "acc_code_random", _wrap_acc_code_random, METH_VARARGS, NULL},
	 { "acc_code___iand__", _wrap_acc_code___iand__, METH_VARARGS, NULL},
	 { "acc_code___and__", _wrap_acc_code___and__, METH_VARARGS, NULL},
	 { "acc_code___ior__", _wrap_acc_code___ior__, METH_VARARGS, NULL},
	 { "acc_code___or__", _wrap_acc_code___or__, METH_VARARGS, NULL},
	 { "acc_code___ilshift__", _wrap_acc_code___ilshift__, METH_VARARGS, NULL},
	 { "acc_code___lshift__", _wrap_acc_code___lshift__, METH_VARARGS, NULL},
	 { "acc_code_is_dnf", _wrap_acc_code_is_dnf, METH_O, NULL},
	 { "acc_code_is_cnf", _wrap_acc_code_is_cnf, METH_O, NULL},
	 { "acc_code_to_dnf", _wrap_acc_code_to_dnf, METH_O, NULL},
	 { "acc_code_to_cnf", _wrap_acc_code_to_cnf, METH_O, NULL},
	 { "acc_code_to_bdd", _wrap_acc_code_to_bdd, METH_VARARGS, NULL},
	 { "acc_code_top_disjuncts", _wrap_acc_code_top_disjuncts, METH_O, NULL},
	 { "acc_code_top_conjuncts", _wrap_acc_code_top_conjuncts, METH_O, NULL},
	 { "acc_code_complement", _wrap_acc_code_complement, METH_O, NULL},
	 { "acc_code_fin_unit", _wrap_acc_code_fin_unit, METH_O, NULL},
	 { "acc_code_inf_unit", _wrap_acc_code_inf_unit, METH_O, NULL},
	 { "acc_code_fin_one", _wrap_acc_code_fin_one, METH_O, NULL},
	 { "acc_code_fin_one_extract", _wrap_acc_code_fin_one_extract, METH_O, NULL},
	 { "acc_code_fin_unit_one_split", _wrap_acc_code_fin_unit_one_split, METH_O, NULL},
	 { "acc_code_missing", _wrap_acc_code_missing, METH_VARARGS, NULL},
	 { "acc_code_accepting", _wrap_acc_code_accepting, METH_VARARGS, NULL},
	 { "acc_code_inf_satisfiable", _wrap_acc_code_inf_satisfiable, METH_VARARGS, NULL},
	 { "acc_code_maybe_accepting", _wrap_acc_code_maybe_accepting, METH_VARARGS, NULL},
	 { "acc_code_symmetries", _wrap_acc_code_symmetries, METH_O, NULL},
	 { "acc_code_remove", _wrap_acc_code_remove, METH_VARARGS, NULL},
	 { "acc_code_strip", _wrap_acc_code_strip, METH_VARARGS, NULL},
	 { "acc_code_force_inf", _wrap_acc_code_force_inf, METH_VARARGS, NULL},
	 { "acc_code_used_sets", _wrap_acc_code_used_sets, METH_O, NULL},
	 { "acc_code_useless_colors_patterns", _wrap_acc_code_useless_colors_patterns, METH_O, NULL},
	 { "acc_code_used_once_sets", _wrap_acc_code_used_once_sets, METH_O, NULL},
	 { "acc_code_used_inf_fin_sets", _wrap_acc_code_used_inf_fin_sets, METH_O, NULL},
	 { "acc_code_to_html", _wrap_acc_code_to_html, METH_VARARGS, NULL},
	 { "acc_code_to_text", _wrap_acc_code_to_text, METH_VARARGS, NULL},
	 { "acc_code_to_latex", _wrap_acc_code_to_latex, METH_VARARGS, NULL},
	 { "new_acc_code", _wrap_new_acc_code, METH_VARARGS, NULL},
	 { "acc_code___repr__", _wrap_acc_code___repr__, METH_O, NULL},
	 { "acc_code___str__", _wrap_acc_code___str__, METH_O, NULL},
	 { "delete_acc_code", _wrap_delete_acc_code, METH_O, NULL},
	 { "acc_code_swigregister", acc_code_swigregister, METH_O, NULL},
	 { "acc_code_swiginit", acc_code_swiginit, METH_VARARGS, NULL},
	 { "new_rs_pair", _wrap_new_rs_pair, METH_VARARGS, NULL},
	 { "rs_pair_fin_set", _wrap_rs_pair_fin_set, METH_VARARGS, NULL},
	 { "rs_pair_fin_get", _wrap_rs_pair_fin_get, METH_O, NULL},
	 { "rs_pair_inf_set", _wrap_rs_pair_inf_set, METH_VARARGS, NULL},
	 { "rs_pair_inf_get", _wrap_rs_pair_inf_get, METH_O, NULL},
	 { "rs_pair___eq__", _wrap_rs_pair___eq__, METH_VARARGS, NULL},
	 { "rs_pair___ne__", _wrap_rs_pair___ne__, METH_VARARGS, NULL},
	 { "rs_pair___lt__", _wrap_rs_pair___lt__, METH_VARARGS, NULL},
	 { "rs_pair___le__", _wrap_rs_pair___le__, METH_VARARGS, NULL},
	 { "rs_pair___gt__", _wrap_rs_pair___gt__, METH_VARARGS, NULL},
	 { "rs_pair___ge__", _wrap_rs_pair___ge__, METH_VARARGS, NULL},
	 { "rs_pair___repr__", _wrap_rs_pair___repr__, METH_O, NULL},
	 { "delete_rs_pair", _wrap_delete_rs_pair, METH_O, NULL},
	 { "rs_pair_swigregister", rs_pair_swigregister, METH_O, NULL},
	 { "rs_pair_swiginit", rs_pair_swiginit, METH_VARARGS, NULL},
	 { "new_rs_pairs_view", _wrap_new_rs_pairs_view, METH_VARARGS, NULL},
	 { "rs_pairs_view_infs", _wrap_rs_pairs_view_infs, METH_O, NULL},
	 { "rs_pairs_view_fins", _wrap_rs_pairs_view_fins, METH_O, NULL},
	 { "rs_pairs_view_fins_alone", _wrap_rs_pairs_view_fins_alone, METH_O, NULL},
	 { "rs_pairs_view_infs_alone", _wrap_rs_pairs_view_infs_alone, METH_O, NULL},
	 { "rs_pairs_view_paired_with_fin", _wrap_rs_pairs_view_paired_with_fin, METH_VARARGS, NULL},
	 { "rs_pairs_view_pairs", _wrap_rs_pairs_view_pairs, METH_O, NULL},
	 { "delete_rs_pairs_view", _wrap_delete_rs_pairs_view, METH_O, NULL},
	 { "rs_pairs_view_swigregister", rs_pairs_view_swigregister, METH_O, NULL},
	 { "rs_pairs_view_swiginit", rs_pairs_view_swiginit, METH_VARARGS, NULL},
	 { "new_mark_iterator", _wrap_new_mark_iterator, METH_VARARGS, NULL},
	 { "mark_iterator___eq__", _wrap_mark_iterator___eq__, METH_VARARGS, NULL},
	 { "mark_iterator___ne__", _wrap_mark_iterator___ne__, METH_VARARGS, NULL},
	 { "mark_iterator___ref__", _wrap_mark_iterator___ref__, METH_O, NULL},
	 { "delete_mark_iterator", _wrap_delete_mark_iterator, METH_O, NULL},
	 { "mark_iterator_swigregister", mark_iterator_swigregister, METH_O, NULL},
	 { "mark_iterator_swiginit", mark_iterator_swiginit, METH_VARARGS, NULL},
	 { "new_mark_container", _wrap_new_mark_container, METH_O, NULL},
	 { "mark_container_begin", _wrap_mark_container_begin, METH_O, NULL},
	 { "mark_container_end", _wrap_mark_container_end, METH_O, NULL},
	 { "mark_container___iter__", _wrap_mark_container___iter__, METH_O, NULL},
	 { "delete_mark_container", _wrap_delete_mark_container, METH_O, NULL},
	 { "mark_container_swigregister", mark_container_swigregister, METH_O, NULL},
	 { "mark_container_swiginit", mark_container_swiginit, METH_VARARGS, NULL},
	 { "new_pair_bool_mark", _wrap_new_pair_bool_mark, METH_VARARGS, NULL},
	 { "pair_bool_mark_first_set", _wrap_pair_bool_mark_first_set, METH_VARARGS, NULL},
	 { "pair_bool_mark_first_get", _wrap_pair_bool_mark_first_get, METH_O, NULL},
	 { "pair_bool_mark_second_set", _wrap_pair_bool_mark_second_set, METH_VARARGS, NULL},
	 { "pair_bool_mark_second_get", _wrap_pair_bool_mark_second_get, METH_O, NULL},
	 { "delete_pair_bool_mark", _wrap_delete_pair_bool_mark, METH_O, NULL},
	 { "pair_bool_mark_swigregister", pair_bool_mark_swigregister, METH_O, NULL},
	 { "pair_bool_mark_swiginit", pair_bool_mark_swiginit, METH_VARARGS, NULL},
	 { "state_compare", _wrap_state_compare, METH_VARARGS, NULL},
	 { "state_hash", _wrap_state_hash, METH_O, NULL},
	 { "state_clone", _wrap_state_clone, METH_O, NULL},
	 { "state_destroy", _wrap_state_destroy, METH_O, NULL},
	 { "state_swigregister", state_swigregister, METH_O, NULL},
	 { "state_ptr_less_than___call__", _wrap_state_ptr_less_than___call__, METH_VARARGS, NULL},
	 { "new_state_ptr_less_than", _wrap_new_state_ptr_less_than, METH_NOARGS, NULL},
	 { "delete_state_ptr_less_than", _wrap_delete_state_ptr_less_than, METH_O, NULL},
	 { "state_ptr_less_than_swigregister", state_ptr_less_than_swigregister, METH_O, NULL},
	 { "state_ptr_less_than_swiginit", state_ptr_less_than_swiginit, METH_VARARGS, NULL},
	 { "state_ptr_equal___call__", _wrap_state_ptr_equal___call__, METH_VARARGS, NULL},
	 { "new_state_ptr_equal", _wrap_new_state_ptr_equal, METH_NOARGS, NULL},
	 { "delete_state_ptr_equal", _wrap_delete_state_ptr_equal, METH_O, NULL},
	 { "state_ptr_equal_swigregister", state_ptr_equal_swigregister, METH_O, NULL},
	 { "state_ptr_equal_swiginit", state_ptr_equal_swiginit, METH_VARARGS, NULL},
	 { "state_ptr_hash___call__", _wrap_state_ptr_hash___call__, METH_VARARGS, NULL},
	 { "new_state_ptr_hash", _wrap_new_state_ptr_hash, METH_NOARGS, NULL},
	 { "delete_state_ptr_hash", _wrap_delete_state_ptr_hash, METH_O, NULL},
	 { "state_ptr_hash_swigregister", state_ptr_hash_swigregister, METH_O, NULL},
	 { "state_ptr_hash_swiginit", state_ptr_hash_swiginit, METH_VARARGS, NULL},
	 { "state_unicity_table___call__", _wrap_state_unicity_table___call__, METH_VARARGS, NULL},
	 { "state_unicity_table_is_new", _wrap_state_unicity_table_is_new, METH_VARARGS, NULL},
	 { "delete_state_unicity_table", _wrap_delete_state_unicity_table, METH_O, NULL},
	 { "state_unicity_table_size", _wrap_state_unicity_table_size, METH_O, NULL},
	 { "new_state_unicity_table", _wrap_new_state_unicity_table, METH_NOARGS, NULL},
	 { "state_unicity_table_swigregister", state_unicity_table_swigregister, METH_O, NULL},
	 { "state_unicity_table_swiginit", state_unicity_table_swiginit, METH_VARARGS, NULL},
	 { "shared_state_deleter", _wrap_shared_state_deleter, METH_O, NULL},
	 { "state_shared_ptr_less_than___call__", _wrap_state_shared_ptr_less_than___call__, METH_VARARGS, NULL},
	 { "new_state_shared_ptr_less_than", _wrap_new_state_shared_ptr_less_than, METH_NOARGS, NULL},
	 { "delete_state_shared_ptr_less_than", _wrap_delete_state_shared_ptr_less_than, METH_O, NULL},
	 { "state_shared_ptr_less_than_swigregister", state_shared_ptr_less_than_swigregister, METH_O, NULL},
	 { "state_shared_ptr_less_than_swiginit", state_shared_ptr_less_than_swiginit, METH_VARARGS, NULL},
	 { "state_shared_ptr_equal___call__", _wrap_state_shared_ptr_equal___call__, METH_VARARGS, NULL},
	 { "new_state_shared_ptr_equal", _wrap_new_state_shared_ptr_equal, METH_NOARGS, NULL},
	 { "delete_state_shared_ptr_equal", _wrap_delete_state_shared_ptr_equal, METH_O, NULL},
	 { "state_shared_ptr_equal_swigregister", state_shared_ptr_equal_swigregister, METH_O, NULL},
	 { "state_shared_ptr_equal_swiginit", state_shared_ptr_equal_swiginit, METH_VARARGS, NULL},
	 { "state_shared_ptr_hash___call__", _wrap_state_shared_ptr_hash___call__, METH_VARARGS, NULL},
	 { "new_state_shared_ptr_hash", _wrap_new_state_shared_ptr_hash, METH_NOARGS, NULL},
	 { "delete_state_shared_ptr_hash", _wrap_delete_state_shared_ptr_hash, METH_O, NULL},
	 { "state_shared_ptr_hash_swigregister", state_shared_ptr_hash_swigregister, METH_O, NULL},
	 { "state_shared_ptr_hash_swiginit", state_shared_ptr_hash_swiginit, METH_VARARGS, NULL},
	 { "delete_twa_succ_iterator", _wrap_delete_twa_succ_iterator, METH_O, NULL},
	 { "twa_succ_iterator_first", _wrap_twa_succ_iterator_first, METH_O, NULL},
	 { "twa_succ_iterator_next", _wrap_twa_succ_iterator_next, METH_O, NULL},
	 { "twa_succ_iterator_done", _wrap_twa_succ_iterator_done, METH_O, NULL},
	 { "twa_succ_iterator_dst", _wrap_twa_succ_iterator_dst, METH_O, NULL},
	 { "twa_succ_iterator_cond", _wrap_twa_succ_iterator_cond, METH_O, NULL},
	 { "twa_succ_iterator_acc", _wrap_twa_succ_iterator_acc, METH_O, NULL},
	 { "twa_succ_iterator_swigregister", twa_succ_iterator_swigregister, METH_O, NULL},
	 { "new_succ_iterator", _wrap_new_succ_iterator, METH_O, NULL},
	 { "succ_iterator___eq__", _wrap_succ_iterator___eq__, METH_VARARGS, NULL},
	 { "succ_iterator___ne__", _wrap_succ_iterator___ne__, METH_VARARGS, NULL},
	 { "succ_iterator___ref__", _wrap_succ_iterator___ref__, METH_O, NULL},
	 { "delete_succ_iterator", _wrap_delete_succ_iterator, METH_O, NULL},
	 { "succ_iterator_swigregister", succ_iterator_swigregister, METH_O, NULL},
	 { "succ_iterator_swiginit", succ_iterator_swiginit, METH_VARARGS, NULL},
	 { "delete_twa", _wrap_delete_twa, METH_O, NULL},
	 { "twa_get_init_state", _wrap_twa_get_init_state, METH_O, NULL},
	 { "twa_succ_iter", _wrap_twa_succ_iter, METH_VARARGS, NULL},
	 { "twa_release_iter", _wrap_twa_release_iter, METH_VARARGS, NULL},
	 { "twa_get_dict", _wrap_twa_get_dict, METH_O, NULL},
	 { "twa_register_ap", _wrap_twa_register_ap, METH_VARARGS, NULL},
	 { "twa_unregister_ap", _wrap_twa_unregister_ap, METH_VARARGS, NULL},
	 { "twa_register_aps_from_dict", _wrap_twa_register_aps_from_dict, METH_O, NULL},
	 { "twa_ap", _wrap_twa_ap, METH_O, NULL},
	 { "twa_ap_vars", _wrap_twa_ap_vars, METH_O, NULL},
	 { "twa_format_state", _wrap_twa_format_state, METH_VARARGS, NULL},
	 { "twa_project_state", _wrap_twa_project_state, METH_VARARGS, NULL},
	 { "twa_acc", _wrap_twa_acc, METH_VARARGS, NULL},
	 { "twa_is_empty", _wrap_twa_is_empty, METH_O, NULL},
	 { "twa_accepting_run", _wrap_twa_accepting_run, METH_O, NULL},
	 { "twa_accepting_word", _wrap_twa_accepting_word, METH_O, NULL},
	 { "twa_intersects", _wrap_twa_intersects, METH_VARARGS, NULL},
	 { "twa_intersecting_run", _wrap_twa_intersecting_run, METH_VARARGS, NULL},
	 { "twa_intersecting_word", _wrap_twa_intersecting_word, METH_VARARGS, NULL},
	 { "twa_exclusive_run", _wrap_twa_exclusive_run, METH_VARARGS, NULL},
	 { "twa_exclusive_word", _wrap_twa_exclusive_word, METH_VARARGS, NULL},
	 { "twa_num_sets", _wrap_twa_num_sets, METH_O, NULL},
	 { "twa_get_acceptance", _wrap_twa_get_acceptance, METH_O, NULL},
	 { "twa_set_acceptance", _wrap_twa_set_acceptance, METH_VARARGS, NULL},
	 { "twa_copy_acceptance_of", _wrap_twa_copy_acceptance_of, METH_VARARGS, NULL},
	 { "twa_copy_ap_of", _wrap_twa_copy_ap_of, METH_VARARGS, NULL},
	 { "twa_copy_named_properties_of", _wrap_twa_copy_named_properties_of, METH_VARARGS, NULL},
	 { "twa_set_generalized_buchi", _wrap_twa_set_generalized_buchi, METH_VARARGS, NULL},
	 { "twa_set_generalized_co_buchi", _wrap_twa_set_generalized_co_buchi, METH_VARARGS, NULL},
	 { "twa_set_buchi", _wrap_twa_set_buchi, METH_O, NULL},
	 { "twa_set_co_buchi", _wrap_twa_set_co_buchi, METH_O, NULL},
	 { "twa_release_named_properties", _wrap_twa_release_named_properties, METH_O, NULL},
	 { "twa_prop_state_acc", _wrap_twa_prop_state_acc, METH_VARARGS, NULL},
	 { "twa_is_sba", _wrap_twa_is_sba, METH_O, NULL},
	 { "twa_prop_inherently_weak", _wrap_twa_prop_inherently_weak, METH_VARARGS, NULL},
	 { "twa_prop_terminal", _wrap_twa_prop_terminal, METH_VARARGS, NULL},
	 { "twa_prop_weak", _wrap_twa_prop_weak, METH_VARARGS, NULL},
	 { "twa_prop_very_weak", _wrap_twa_prop_very_weak, METH_VARARGS, NULL},
	 { "twa_prop_complete", _wrap_twa_prop_complete, METH_VARARGS, NULL},
	 { "twa_prop_universal", _wrap_twa_prop_universal, METH_VARARGS, NULL},
	 { "twa_prop_deterministic", _wrap_twa_prop_deterministic, METH_VARARGS, NULL},
	 { "twa_prop_unambiguous", _wrap_twa_prop_unambiguous, METH_VARARGS, NULL},
	 { "twa_prop_semi_deterministic", _wrap_twa_prop_semi_deterministic, METH_VARARGS, NULL},
	 { "twa_prop_stutter_invariant", _wrap_twa_prop_stutter_invariant, METH_VARARGS, NULL},
	 { "twa_prop_copy", _wrap_twa_prop_copy, METH_VARARGS, NULL},
	 { "twa_prop_keep", _wrap_twa_prop_keep, METH_VARARGS, NULL},
	 { "twa_prop_reset", _wrap_twa_prop_reset, METH_O, NULL},
	 { "twa_set_name", _wrap_twa_set_name, METH_VARARGS, NULL},
	 { "twa_get_name", _wrap_twa_get_name, METH_O, NULL},
	 { "twa_set_state_names", _wrap_twa_set_state_names, METH_VARARGS, NULL},
	 { "twa_get_state_names", _wrap_twa_get_state_names, METH_O, NULL},
	 { "twa_set_product_states", _wrap_twa_set_product_states, METH_VARARGS, NULL},
	 { "twa_get_product_states", _wrap_twa_get_product_states, METH_O, NULL},
	 { "twa_get_original_states", _wrap_twa_get_original_states, METH_O, NULL},
	 { "twa_get_original_classes", _wrap_twa_get_original_classes, METH_O, NULL},
	 { "twa_highlight_state", _wrap_twa_highlight_state, METH_VARARGS, NULL},
	 { "twa_highlight_edge", _wrap_twa_highlight_edge, METH_VARARGS, NULL},
	 { "twa_swigregister", twa_swigregister, METH_O, NULL},
	 { "twa_prop_set_state_based_set", _wrap_twa_prop_set_state_based_set, METH_VARARGS, NULL},
	 { "twa_prop_set_state_based_get", _wrap_twa_prop_set_state_based_get, METH_O, NULL},
	 { "twa_prop_set_inherently_weak_set", _wrap_twa_prop_set_inherently_weak_set, METH_VARARGS, NULL},
	 { "twa_prop_set_inherently_weak_get", _wrap_twa_prop_set_inherently_weak_get, METH_O, NULL},
	 { "twa_prop_set_deterministic_set", _wrap_twa_prop_set_deterministic_set, METH_VARARGS, NULL},
	 { "twa_prop_set_deterministic_get", _wrap_twa_prop_set_deterministic_get, METH_O, NULL},
	 { "twa_prop_set_improve_det_set", _wrap_twa_prop_set_improve_det_set, METH_VARARGS, NULL},
	 { "twa_prop_set_improve_det_get", _wrap_twa_prop_set_improve_det_get, METH_O, NULL},
	 { "twa_prop_set_complete_set", _wrap_twa_prop_set_complete_set, METH_VARARGS, NULL},
	 { "twa_prop_set_complete_get", _wrap_twa_prop_set_complete_get, METH_O, NULL},
	 { "twa_prop_set_stutter_inv_set", _wrap_twa_prop_set_stutter_inv_set, METH_VARARGS, NULL},
	 { "twa_prop_set_stutter_inv_get", _wrap_twa_prop_set_stutter_inv_get, METH_O, NULL},
	 { "new_twa_prop_set", _wrap_new_twa_prop_set, METH_VARARGS, NULL},
	 { "twa_prop_set_all", _wrap_twa_prop_set_all, METH_NOARGS, NULL},
	 { "delete_twa_prop_set", _wrap_delete_twa_prop_set, METH_O, NULL},
	 { "twa_prop_set_swigregister", twa_prop_set_swigregister, METH_O, NULL},
	 { "twa_prop_set_swiginit", twa_prop_set_swiginit, METH_VARARGS, NULL},
	 { "create_atomic_prop_set", _wrap_create_atomic_prop_set, METH_O, NULL},
	 { "atomic_prop_collect", _wrap_atomic_prop_collect, METH_VARARGS, NULL},
	 { "atomic_prop_collect_as_bdd", _wrap_atomic_prop_collect_as_bdd, METH_VARARGS, NULL},
	 { "new_language_containment_checker", _wrap_new_language_containment_checker, METH_VARARGS, NULL},
	 { "delete_language_containment_checker", _wrap_delete_language_containment_checker, METH_O, NULL},
	 { "language_containment_checker_clear", _wrap_language_containment_checker_clear, METH_O, NULL},
	 { "language_containment_checker_contained", _wrap_language_containment_checker_contained, METH_VARARGS, NULL},
	 { "language_containment_checker_neg_contained", _wrap_language_containment_checker_neg_contained, METH_VARARGS, NULL},
	 { "language_containment_checker_contained_neg", _wrap_language_containment_checker_contained_neg, METH_VARARGS, NULL},
	 { "language_containment_checker_equal", _wrap_language_containment_checker_equal, METH_VARARGS, NULL},
	 { "language_containment_checker_swigregister", language_containment_checker_swigregister, METH_O, NULL},
	 { "language_containment_checker_swiginit", language_containment_checker_swiginit, METH_VARARGS, NULL},
	 { "print_dot_psl", _wrap_print_dot_psl, METH_VARARGS, NULL},
	 { "negative_normal_form", _wrap_negative_normal_form, METH_VARARGS, NULL},
	 { "suffix_operator_normal_form", _wrap_suffix_operator_normal_form, METH_VARARGS, NULL},
	 { "print_psl", _wrap_print_psl, METH_VARARGS, NULL},
	 { "str_psl", _wrap_str_psl, METH_VARARGS, NULL},
	 { "print_utf8_psl", _wrap_print_utf8_psl, METH_VARARGS, NULL},
	 { "str_utf8_psl", _wrap_str_utf8_psl, METH_VARARGS, NULL},
	 { "print_sere", _wrap_print_sere, METH_VARARGS, NULL},
	 { "str_sere", _wrap_str_sere, METH_VARARGS, NULL},
	 { "print_utf8_sere", _wrap_print_utf8_sere, METH_VARARGS, NULL},
	 { "str_utf8_sere", _wrap_str_utf8_sere, METH_VARARGS, NULL},
	 { "print_spin_ltl", _wrap_print_spin_ltl, METH_VARARGS, NULL},
	 { "str_spin_ltl", _wrap_str_spin_ltl, METH_VARARGS, NULL},
	 { "print_wring_ltl", _wrap_print_wring_ltl, METH_VARARGS, NULL},
	 { "str_wring_ltl", _wrap_str_wring_ltl, METH_O, NULL},
	 { "print_latex_psl", _wrap_print_latex_psl, METH_VARARGS, NULL},
	 { "str_latex_psl", _wrap_str_latex_psl, METH_VARARGS, NULL},
	 { "print_latex_sere", _wrap_print_latex_sere, METH_VARARGS, NULL},
	 { "str_latex_sere", _wrap_str_latex_sere, METH_VARARGS, NULL},
	 { "print_sclatex_psl", _wrap_print_sclatex_psl, METH_VARARGS, NULL},
	 { "str_sclatex_psl", _wrap_str_sclatex_psl, METH_VARARGS, NULL},
	 { "print_sclatex_sere", _wrap_print_sclatex_sere, METH_VARARGS, NULL},
	 { "str_sclatex_sere", _wrap_str_sclatex_sere, METH_VARARGS, NULL},
	 { "print_lbt_ltl", _wrap_print_lbt_ltl, METH_VARARGS, NULL},
	 { "str_lbt_ltl", _wrap_str_lbt_ltl, METH_O, NULL},
	 { "new_tl_simplifier_options", _wrap_new_tl_simplifier_options, METH_VARARGS, NULL},
	 { "tl_simplifier_options_reduce_basics_set", _wrap_tl_simplifier_options_reduce_basics_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_reduce_basics_get", _wrap_tl_simplifier_options_reduce_basics_get, METH_O, NULL},
	 { "tl_simplifier_options_synt_impl_set", _wrap_tl_simplifier_options_synt_impl_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_synt_impl_get", _wrap_tl_simplifier_options_synt_impl_get, METH_O, NULL},
	 { "tl_simplifier_options_event_univ_set", _wrap_tl_simplifier_options_event_univ_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_event_univ_get", _wrap_tl_simplifier_options_event_univ_get, METH_O, NULL},
	 { "tl_simplifier_options_containment_checks_set", _wrap_tl_simplifier_options_containment_checks_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_containment_checks_get", _wrap_tl_simplifier_options_containment_checks_get, METH_O, NULL},
	 { "tl_simplifier_options_containment_checks_stronger_set", _wrap_tl_simplifier_options_containment_checks_stronger_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_containment_checks_stronger_get", _wrap_tl_simplifier_options_containment_checks_stronger_get, METH_O, NULL},
	 { "tl_simplifier_options_nenoform_stop_on_boolean_set", _wrap_tl_simplifier_options_nenoform_stop_on_boolean_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_nenoform_stop_on_boolean_get", _wrap_tl_simplifier_options_nenoform_stop_on_boolean_get, METH_O, NULL},
	 { "tl_simplifier_options_reduce_size_strictly_set", _wrap_tl_simplifier_options_reduce_size_strictly_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_reduce_size_strictly_get", _wrap_tl_simplifier_options_reduce_size_strictly_get, METH_O, NULL},
	 { "tl_simplifier_options_boolean_to_isop_set", _wrap_tl_simplifier_options_boolean_to_isop_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_boolean_to_isop_get", _wrap_tl_simplifier_options_boolean_to_isop_get, METH_O, NULL},
	 { "tl_simplifier_options_favor_event_univ_set", _wrap_tl_simplifier_options_favor_event_univ_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_favor_event_univ_get", _wrap_tl_simplifier_options_favor_event_univ_get, METH_O, NULL},
	 { "tl_simplifier_options_keep_top_xor_set", _wrap_tl_simplifier_options_keep_top_xor_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_keep_top_xor_get", _wrap_tl_simplifier_options_keep_top_xor_get, METH_O, NULL},
	 { "tl_simplifier_options_containment_max_states_set", _wrap_tl_simplifier_options_containment_max_states_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_containment_max_states_get", _wrap_tl_simplifier_options_containment_max_states_get, METH_O, NULL},
	 { "tl_simplifier_options_containment_max_ops_set", _wrap_tl_simplifier_options_containment_max_ops_set, METH_VARARGS, NULL},
	 { "tl_simplifier_options_containment_max_ops_get", _wrap_tl_simplifier_options_containment_max_ops_get, METH_O, NULL},
	 { "delete_tl_simplifier_options", _wrap_delete_tl_simplifier_options, METH_O, NULL},
	 { "tl_simplifier_options_swigregister", tl_simplifier_options_swigregister, METH_O, NULL},
	 { "tl_simplifier_options_swiginit", tl_simplifier_options_swiginit, METH_VARARGS, NULL},
	 { "new_tl_simplifier", _wrap_new_tl_simplifier, METH_VARARGS, NULL},
	 { "delete_tl_simplifier", _wrap_delete_tl_simplifier, METH_O, NULL},
	 { "tl_simplifier_simplify", _wrap_tl_simplifier_simplify, METH_VARARGS, NULL},
	 { "tl_simplifier_negative_normal_form", _wrap_tl_simplifier_negative_normal_form, METH_VARARGS, NULL},
	 { "tl_simplifier_syntactic_implication", _wrap_tl_simplifier_syntactic_implication, METH_VARARGS, NULL},
	 { "tl_simplifier_syntactic_implication_neg", _wrap_tl_simplifier_syntactic_implication_neg, METH_VARARGS, NULL},
	 { "tl_simplifier_are_equivalent", _wrap_tl_simplifier_are_equivalent, METH_VARARGS, NULL},
	 { "tl_simplifier_implication", _wrap_tl_simplifier_implication, METH_VARARGS, NULL},
	 { "tl_simplifier_as_bdd", _wrap_tl_simplifier_as_bdd, METH_VARARGS, NULL},
	 { "tl_simplifier_clear_as_bdd_cache", _wrap_tl_simplifier_clear_as_bdd_cache, METH_O, NULL},
	 { "tl_simplifier_clear_caches", _wrap_tl_simplifier_clear_caches, METH_O, NULL},
	 { "tl_simplifier_get_dict", _wrap_tl_simplifier_get_dict, METH_O, NULL},
	 { "tl_simplifier_star_normal_form", _wrap_tl_simplifier_star_normal_form, METH_VARARGS, NULL},
	 { "tl_simplifier_boolean_to_isop", _wrap_tl_simplifier_boolean_to_isop, METH_VARARGS, NULL},
	 { "tl_simplifier_print_stats", _wrap_tl_simplifier_print_stats, METH_VARARGS, NULL},
	 { "tl_simplifier_swigregister", tl_simplifier_swigregister, METH_O, NULL},
	 { "tl_simplifier_swiginit", tl_simplifier_swiginit, METH_VARARGS, NULL},
	 { "new_unabbreviator", _wrap_new_unabbreviator, METH_VARARGS, NULL},
	 { "unabbreviator_run", _wrap_unabbreviator_run, METH_VARARGS, NULL},
	 { "delete_unabbreviator", _wrap_delete_unabbreviator, METH_O, NULL},
	 { "unabbreviator_swigregister", unabbreviator_swigregister, METH_O, NULL},
	 { "unabbreviator_swiginit", unabbreviator_swiginit, METH_VARARGS, NULL},
	 { "unabbreviate", _wrap_unabbreviate, METH_VARARGS, NULL},
	 { "new_random_formula", _wrap_new_random_formula, METH_VARARGS, NULL},
	 { "delete_random_formula", _wrap_delete_random_formula, METH_O, NULL},
	 { "random_formula_ap", _wrap_random_formula_ap, METH_O, NULL},
	 { "random_formula_generate", _wrap_random_formula_generate, METH_VARARGS, NULL},
	 { "random_formula_dump_priorities", _wrap_random_formula_dump_priorities, METH_VARARGS, NULL},
	 { "random_formula_parse_options", _wrap_random_formula_parse_options, METH_VARARGS, NULL},
	 { "random_formula_swigregister", random_formula_swigregister, METH_O, NULL},
	 { "random_formula_swiginit", random_formula_swiginit, METH_VARARGS, NULL},
	 { "new_random_ltl", _wrap_new_random_ltl, METH_O, NULL},
	 { "delete_random_ltl", _wrap_delete_random_ltl, METH_O, NULL},
	 { "random_ltl_swigregister", random_ltl_swigregister, METH_O, NULL},
	 { "random_ltl_swiginit", random_ltl_swiginit, METH_VARARGS, NULL},
	 { "new_random_boolean", _wrap_new_random_boolean, METH_O, NULL},
	 { "delete_random_boolean", _wrap_delete_random_boolean, METH_O, NULL},
	 { "random_boolean_swigregister", random_boolean_swigregister, METH_O, NULL},
	 { "random_boolean_swiginit", random_boolean_swiginit, METH_VARARGS, NULL},
	 { "new_random_sere", _wrap_new_random_sere, METH_O, NULL},
	 { "random_sere_rb_set", _wrap_random_sere_rb_set, METH_VARARGS, NULL},
	 { "random_sere_rb_get", _wrap_random_sere_rb_get, METH_O, NULL},
	 { "delete_random_sere", _wrap_delete_random_sere, METH_O, NULL},
	 { "random_sere_swigregister", random_sere_swigregister, METH_O, NULL},
	 { "random_sere_swiginit", random_sere_swiginit, METH_VARARGS, NULL},
	 { "new_random_psl", _wrap_new_random_psl, METH_O, NULL},
	 { "random_psl_rs_set", _wrap_random_psl_rs_set, METH_VARARGS, NULL},
	 { "random_psl_rs_get", _wrap_random_psl_rs_get, METH_O, NULL},
	 { "delete_random_psl", _wrap_delete_random_psl, METH_O, NULL},
	 { "random_psl_swigregister", random_psl_swigregister, METH_O, NULL},
	 { "random_psl_swiginit", random_psl_swiginit, METH_VARARGS, NULL},
	 { "new_randltlgenerator", _wrap_new_randltlgenerator, METH_VARARGS, NULL},
	 { "delete_randltlgenerator", _wrap_delete_randltlgenerator, METH_O, NULL},
	 { "randltlgenerator_next", _wrap_randltlgenerator_next, METH_O, NULL},
	 { "randltlgenerator_dump_ltl_priorities", _wrap_randltlgenerator_dump_ltl_priorities, METH_VARARGS, NULL},
	 { "randltlgenerator_dump_bool_priorities", _wrap_randltlgenerator_dump_bool_priorities, METH_VARARGS, NULL},
	 { "randltlgenerator_dump_psl_priorities", _wrap_randltlgenerator_dump_psl_priorities, METH_VARARGS, NULL},
	 { "randltlgenerator_dump_sere_priorities", _wrap_randltlgenerator_dump_sere_priorities, METH_VARARGS, NULL},
	 { "randltlgenerator_dump_sere_bool_priorities", _wrap_randltlgenerator_dump_sere_bool_priorities, METH_VARARGS, NULL},
	 { "randltlgenerator_remove_some_props", _wrap_randltlgenerator_remove_some_props, METH_VARARGS, NULL},
	 { "randltlgenerator_GF_n", _wrap_randltlgenerator_GF_n, METH_O, NULL},
	 { "randltlgenerator_swigregister", randltlgenerator_swigregister, METH_O, NULL},
	 { "randltlgenerator_swiginit", randltlgenerator_swiginit, METH_VARARGS, NULL},
	 { "length", _wrap_length, METH_O, NULL},
	 { "length_boolone", _wrap_length_boolone, METH_O, NULL},
	 { "from_ltlf", _wrap_from_ltlf, METH_VARARGS, NULL},
	 { "is_persistence", _wrap_is_persistence, METH_VARARGS, NULL},
	 { "is_recurrence", _wrap_is_recurrence, METH_VARARGS, NULL},
	 { "is_obligation", _wrap_is_obligation, METH_VARARGS, NULL},
	 { "mp_class", _wrap_mp_class, METH_VARARGS, NULL},
	 { "nesting_depth", _wrap_nesting_depth, METH_VARARGS, NULL},
	 { "is_liveness", _wrap_is_liveness, METH_O, NULL},
	 { "remove_x", _wrap_remove_x, METH_O, NULL},
	 { "relabel", _wrap_relabel, METH_VARARGS, NULL},
	 { "relabel_bse", _wrap_relabel_bse, METH_VARARGS, NULL},
	 { "relabel_apply", _wrap_relabel_apply, METH_VARARGS, NULL},
	 { "taa_tgba_add_condition", _wrap_taa_tgba_add_condition, METH_VARARGS, NULL},
	 { "delete_taa_tgba", _wrap_delete_taa_tgba, METH_O, NULL},
	 { "taa_tgba_get_init_state", _wrap_taa_tgba_get_init_state, METH_O, NULL},
	 { "taa_tgba_swigregister", taa_tgba_swigregister, METH_O, NULL},
	 { "new_set_state", _wrap_new_set_state, METH_VARARGS, NULL},
	 { "set_state_clone", _wrap_set_state_clone, METH_O, NULL},
	 { "delete_set_state", _wrap_delete_set_state, METH_O, NULL},
	 { "set_state_get_state", _wrap_set_state_get_state, METH_O, NULL},
	 { "set_state_swigregister", set_state_swigregister, METH_O, NULL},
	 { "set_state_swiginit", set_state_swiginit, METH_VARARGS, NULL},
	 { "new_taa_succ_iterator", _wrap_new_taa_succ_iterator, METH_VARARGS, NULL},
	 { "delete_taa_succ_iterator", _wrap_delete_taa_succ_iterator, METH_O, NULL},
	 { "taa_succ_iterator_dst", _wrap_taa_succ_iterator_dst, METH_O, NULL},
	 { "taa_succ_iterator_swigregister", taa_succ_iterator_swigregister, METH_O, NULL},
	 { "taa_succ_iterator_swiginit", taa_succ_iterator_swiginit, METH_VARARGS, NULL},
	 { "delete_taa_tgba_string", _wrap_delete_taa_tgba_string, METH_O, NULL},
	 { "taa_tgba_string_swigregister", taa_tgba_string_swigregister, METH_O, NULL},
	 { "make_taa_tgba_string", _wrap_make_taa_tgba_string, METH_O, NULL},
	 { "delete_taa_tgba_formula", _wrap_delete_taa_tgba_formula, METH_O, NULL},
	 { "taa_tgba_formula_swigregister", taa_tgba_formula_swigregister, METH_O, NULL},
	 { "make_taa_tgba_formula", _wrap_make_taa_tgba_formula, METH_O, NULL},
	 { "new_state_product", _wrap_new_state_product, METH_VARARGS, NULL},
	 { "state_product_left", _wrap_state_product_left, METH_O, NULL},
	 { "state_product_right", _wrap_state_product_right, METH_O, NULL},
	 { "state_product_clone", _wrap_state_product_clone, METH_O, NULL},
	 { "state_product_swigregister", state_product_swigregister, METH_O, NULL},
	 { "state_product_swiginit", state_product_swiginit, METH_VARARGS, NULL},
	 { "new_twa_product", _wrap_new_twa_product, METH_VARARGS, NULL},
	 { "delete_twa_product", _wrap_delete_twa_product, METH_O, NULL},
	 { "twa_product_left_acc", _wrap_twa_product_left_acc, METH_O, NULL},
	 { "twa_product_right_acc", _wrap_twa_product_right_acc, METH_O, NULL},
	 { "twa_product_swigregister", twa_product_swigregister, METH_O, NULL},
	 { "twa_product_swiginit", twa_product_swiginit, METH_VARARGS, NULL},
	 { "new_twa_product_init", _wrap_new_twa_product_init, METH_VARARGS, NULL},
	 { "delete_twa_product_init", _wrap_delete_twa_product_init, METH_O, NULL},
	 { "twa_product_init_swigregister", twa_product_init_swigregister, METH_O, NULL},
	 { "twa_product_init_swiginit", twa_product_init_swiginit, METH_VARARGS, NULL},
	 { "otf_product", _wrap_otf_product, METH_VARARGS, NULL},
	 { "otf_product_at", _wrap_otf_product_at, METH_VARARGS, NULL},
	 { "new_const_universal_dests", _wrap_new_const_universal_dests, METH_VARARGS, NULL},
	 { "const_universal_dests_begin", _wrap_const_universal_dests_begin, METH_O, NULL},
	 { "const_universal_dests_end", _wrap_const_universal_dests_end, METH_O, NULL},
	 { "const_universal_dests___iter__", _wrap_const_universal_dests___iter__, METH_O, NULL},
	 { "delete_const_universal_dests", _wrap_delete_const_universal_dests, METH_O, NULL},
	 { "const_universal_dests_swigregister", const_universal_dests_swigregister, METH_O, NULL},
	 { "const_universal_dests_swiginit", const_universal_dests_swiginit, METH_VARARGS, NULL},
	 { "new_twa_graph_state", _wrap_new_twa_graph_state, METH_VARARGS, NULL},
	 { "delete_twa_graph_state", _wrap_delete_twa_graph_state, METH_O, NULL},
	 { "twa_graph_state_clone", _wrap_twa_graph_state_clone, METH_O, NULL},
	 { "twa_graph_state_swigregister", twa_graph_state_swigregister, METH_O, NULL},
	 { "twa_graph_state_swiginit", twa_graph_state_swiginit, METH_VARARGS, NULL},
	 { "twa_graph_edge_data_cond_set", _wrap_twa_graph_edge_data_cond_set, METH_VARARGS, NULL},
	 { "twa_graph_edge_data_cond_get", _wrap_twa_graph_edge_data_cond_get, METH_O, NULL},
	 { "twa_graph_edge_data_acc_set", _wrap_twa_graph_edge_data_acc_set, METH_VARARGS, NULL},
	 { "twa_graph_edge_data_acc_get", _wrap_twa_graph_edge_data_acc_get, METH_O, NULL},
	 { "new_twa_graph_edge_data", _wrap_new_twa_graph_edge_data, METH_VARARGS, NULL},
	 { "twa_graph_edge_data___lt__", _wrap_twa_graph_edge_data___lt__, METH_VARARGS, NULL},
	 { "twa_graph_edge_data___eq__", _wrap_twa_graph_edge_data___eq__, METH_VARARGS, NULL},
	 { "delete_twa_graph_edge_data", _wrap_delete_twa_graph_edge_data, METH_O, NULL},
	 { "twa_graph_edge_data_swigregister", twa_graph_edge_data_swigregister, METH_O, NULL},
	 { "twa_graph_edge_data_swiginit", twa_graph_edge_data_swiginit, METH_VARARGS, NULL},
	 { "twa_graph_apply_permutation", _wrap_twa_graph_apply_permutation, METH_VARARGS, NULL},
	 { "new_twa_graph", _wrap_new_twa_graph, METH_VARARGS, NULL},
	 { "delete_twa_graph", _wrap_delete_twa_graph, METH_O, NULL},
	 { "twa_graph_get_graph", _wrap_twa_graph_get_graph, METH_VARARGS, NULL},
	 { "twa_graph_num_states", _wrap_twa_graph_num_states, METH_O, NULL},
	 { "twa_graph_num_edges", _wrap_twa_graph_num_edges, METH_O, NULL},
	 { "twa_graph_set_init_state", _wrap_twa_graph_set_init_state, METH_VARARGS, NULL},
	 { "twa_graph_get_init_state_number", _wrap_twa_graph_get_init_state_number, METH_O, NULL},
	 { "twa_graph_get_init_state", _wrap_twa_graph_get_init_state, METH_O, NULL},
	 { "twa_graph_is_univ_dest", _wrap_twa_graph_is_univ_dest, METH_VARARGS, NULL},
	 { "twa_graph_state_number", _wrap_twa_graph_state_number, METH_VARARGS, NULL},
	 { "twa_graph_state_from_number", _wrap_twa_graph_state_from_number, METH_VARARGS, NULL},
	 { "twa_graph_format_state", _wrap_twa_graph_format_state, METH_VARARGS, NULL},
	 { "twa_graph_edge_number", _wrap_twa_graph_edge_number, METH_VARARGS, NULL},
	 { "twa_graph_edge_data", _wrap_twa_graph_edge_data, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage", _wrap_twa_graph_edge_storage, METH_VARARGS, NULL},
	 { "twa_graph_new_state", _wrap_twa_graph_new_state, METH_O, NULL},
	 { "twa_graph_new_states", _wrap_twa_graph_new_states, METH_VARARGS, NULL},
	 { "twa_graph_new_edge", _wrap_twa_graph_new_edge, METH_VARARGS, NULL},
	 { "twa_graph_new_acc_edge", _wrap_twa_graph_new_acc_edge, METH_VARARGS, NULL},
	 { "twa_graph_out", _wrap_twa_graph_out, METH_VARARGS, NULL},
	 { "twa_graph_out_iteraser", _wrap_twa_graph_out_iteraser, METH_VARARGS, NULL},
	 { "twa_graph_univ_dests", _wrap_twa_graph_univ_dests, METH_VARARGS, NULL},
	 { "twa_graph_is_existential", _wrap_twa_graph_is_existential, METH_O, NULL},
	 { "twa_graph_edges", _wrap_twa_graph_edges, METH_O, NULL},
	 { "twa_graph_is_dead_edge", _wrap_twa_graph_is_dead_edge, METH_VARARGS, NULL},
	 { "twa_graph_merge_edges", _wrap_twa_graph_merge_edges, METH_O, NULL},
	 { "twa_graph_merge_univ_dests", _wrap_twa_graph_merge_univ_dests, METH_O, NULL},
	 { "twa_graph_merge_states", _wrap_twa_graph_merge_states, METH_VARARGS, NULL},
	 { "twa_graph_merge_states_of", _wrap_twa_graph_merge_states_of, METH_VARARGS, NULL},
	 { "twa_graph_purge_dead_states", _wrap_twa_graph_purge_dead_states, METH_O, NULL},
	 { "twa_graph_purge_unreachable_states", _wrap_twa_graph_purge_unreachable_states, METH_VARARGS, NULL},
	 { "twa_graph_remove_unused_ap", _wrap_twa_graph_remove_unused_ap, METH_O, NULL},
	 { "twa_graph_copy_state_names_from", _wrap_twa_graph_copy_state_names_from, METH_VARARGS, NULL},
	 { "twa_graph_state_acc_sets", _wrap_twa_graph_state_acc_sets, METH_VARARGS, NULL},
	 { "twa_graph_state_is_accepting", _wrap_twa_graph_state_is_accepting, METH_VARARGS, NULL},
	 { "twa_graph___eq__", _wrap_twa_graph___eq__, METH_VARARGS, NULL},
	 { "twa_graph_kill_state", _wrap_twa_graph_kill_state, METH_VARARGS, NULL},
	 { "twa_graph_dump_storage_as_dot", _wrap_twa_graph_dump_storage_as_dot, METH_VARARGS, NULL},
	 { "twa_graph_new_univ_edge", _wrap_twa_graph_new_univ_edge, METH_VARARGS, NULL},
	 { "twa_graph_set_univ_init_state", _wrap_twa_graph_set_univ_init_state, METH_VARARGS, NULL},
	 { "twa_graph_report_univ_dest", _wrap_twa_graph_report_univ_dest, METH_VARARGS, NULL},
	 { "twa_graph_swigregister", twa_graph_swigregister, METH_O, NULL},
	 { "twa_graph_swiginit", twa_graph_swiginit, METH_VARARGS, NULL},
	 { "make_twa_graph", _wrap_make_twa_graph, METH_VARARGS, NULL},
	 { "new_twa_graph_state_out", _wrap_new_twa_graph_state_out, METH_VARARGS, NULL},
	 { "twa_graph_state_out_begin", _wrap_twa_graph_state_out_begin, METH_O, NULL},
	 { "twa_graph_state_out_end", _wrap_twa_graph_state_out_end, METH_O, NULL},
	 { "twa_graph_state_out_recycle", _wrap_twa_graph_state_out_recycle, METH_VARARGS, NULL},
	 { "twa_graph_state_out___iter__", _wrap_twa_graph_state_out___iter__, METH_O, NULL},
	 { "delete_twa_graph_state_out", _wrap_delete_twa_graph_state_out, METH_O, NULL},
	 { "twa_graph_state_out_swigregister", twa_graph_state_out_swigregister, METH_O, NULL},
	 { "twa_graph_state_out_swiginit", twa_graph_state_out_swiginit, METH_VARARGS, NULL},
	 { "new_twa_graph_killer_edge_iterator", _wrap_new_twa_graph_killer_edge_iterator, METH_VARARGS, NULL},
	 { "twa_graph_killer_edge_iterator_erase", _wrap_twa_graph_killer_edge_iterator_erase, METH_O, NULL},
	 { "twa_graph_killer_edge_iterator_current", _wrap_twa_graph_killer_edge_iterator_current, METH_O, NULL},
	 { "twa_graph_killer_edge_iterator_advance", _wrap_twa_graph_killer_edge_iterator_advance, METH_O, NULL},
	 { "twa_graph_killer_edge_iterator___bool__", _wrap_twa_graph_killer_edge_iterator___bool__, METH_O, NULL},
	 { "delete_twa_graph_killer_edge_iterator", _wrap_delete_twa_graph_killer_edge_iterator, METH_O, NULL},
	 { "twa_graph_killer_edge_iterator_swigregister", twa_graph_killer_edge_iterator_swigregister, METH_O, NULL},
	 { "twa_graph_killer_edge_iterator_swiginit", twa_graph_killer_edge_iterator_swiginit, METH_VARARGS, NULL},
	 { "new_twa_graph_all_trans", _wrap_new_twa_graph_all_trans, METH_O, NULL},
	 { "twa_graph_all_trans_begin", _wrap_twa_graph_all_trans_begin, METH_O, NULL},
	 { "twa_graph_all_trans_end", _wrap_twa_graph_all_trans_end, METH_O, NULL},
	 { "twa_graph_all_trans___iter__", _wrap_twa_graph_all_trans___iter__, METH_O, NULL},
	 { "delete_twa_graph_all_trans", _wrap_delete_twa_graph_all_trans, METH_O, NULL},
	 { "twa_graph_all_trans_swigregister", twa_graph_all_trans_swigregister, METH_O, NULL},
	 { "twa_graph_all_trans_swiginit", twa_graph_all_trans_swiginit, METH_VARARGS, NULL},
	 { "new_twa_graph_edge_boxed_data", _wrap_new_twa_graph_edge_boxed_data, METH_NOARGS, NULL},
	 { "twa_graph_edge_boxed_data_data", _wrap_twa_graph_edge_boxed_data_data, METH_VARARGS, NULL},
	 { "delete_twa_graph_edge_boxed_data", _wrap_delete_twa_graph_edge_boxed_data, METH_O, NULL},
	 { "twa_graph_edge_boxed_data_swigregister", twa_graph_edge_boxed_data_swigregister, METH_O, NULL},
	 { "twa_graph_edge_boxed_data_swiginit", twa_graph_edge_boxed_data_swiginit, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage_dst_set", _wrap_twa_graph_edge_storage_dst_set, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage_dst_get", _wrap_twa_graph_edge_storage_dst_get, METH_O, NULL},
	 { "twa_graph_edge_storage_next_succ_set", _wrap_twa_graph_edge_storage_next_succ_set, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage_next_succ_get", _wrap_twa_graph_edge_storage_next_succ_get, METH_O, NULL},
	 { "twa_graph_edge_storage_src_set", _wrap_twa_graph_edge_storage_src_set, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage_src_get", _wrap_twa_graph_edge_storage_src_get, METH_O, NULL},
	 { "new_twa_graph_edge_storage", _wrap_new_twa_graph_edge_storage, METH_NOARGS, NULL},
	 { "twa_graph_edge_storage___lt__", _wrap_twa_graph_edge_storage___lt__, METH_VARARGS, NULL},
	 { "twa_graph_edge_storage___eq__", _wrap_twa_graph_edge_storage___eq__, METH_VARARGS, NULL},
	 { "delete_twa_graph_edge_storage", _wrap_delete_twa_graph_edge_storage, METH_O, NULL},
	 { "twa_graph_edge_storage_swigregister", twa_graph_edge_storage_swigregister, METH_O, NULL},
	 { "twa_graph_edge_storage_swiginit", twa_graph_edge_storage_swiginit, METH_VARARGS, NULL},
	 { "new_aig", _wrap_new_aig, METH_VARARGS, NULL},
	 { "delete_aig", _wrap_delete_aig, METH_O, NULL},
	 { "aig_get_safe_point_", _wrap_aig_get_safe_point_, METH_O, NULL},
	 { "aig_roll_back_", _wrap_aig_roll_back_, METH_VARARGS, NULL},
	 { "aig_reapply_", _wrap_aig_reapply_, METH_VARARGS, NULL},
	 { "aig_num_outputs", _wrap_aig_num_outputs, METH_O, NULL},
	 { "aig_outputs", _wrap_aig_outputs, METH_O, NULL},
	 { "aig_output_names", _wrap_aig_output_names, METH_O, NULL},
	 { "aig_num_inputs", _wrap_aig_num_inputs, METH_O, NULL},
	 { "aig_input_names", _wrap_aig_input_names, METH_O, NULL},
	 { "aig_num_latches", _wrap_aig_num_latches, METH_O, NULL},
	 { "aig_next_latches", _wrap_aig_next_latches, METH_O, NULL},
	 { "aig_num_gates", _wrap_aig_num_gates, METH_O, NULL},
	 { "aig_gates", _wrap_aig_gates, METH_O, NULL},
	 { "aig_max_var", _wrap_aig_max_var, METH_O, NULL},
	 { "aig_input_var", _wrap_aig_input_var, METH_VARARGS, NULL},
	 { "aig_input_bdd", _wrap_aig_input_bdd, METH_VARARGS, NULL},
	 { "aig_latch_var", _wrap_aig_latch_var, METH_VARARGS, NULL},
	 { "aig_latch_bdd", _wrap_aig_latch_bdd, METH_VARARGS, NULL},
	 { "aig_gate_var", _wrap_aig_gate_var, METH_VARARGS, NULL},
	 { "aig_gate_bdd", _wrap_aig_gate_bdd, METH_VARARGS, NULL},
	 { "aig_aigvar2bdd", _wrap_aig_aigvar2bdd, METH_VARARGS, NULL},
	 { "aig_bdd2aigvar", _wrap_aig_bdd2aigvar, METH_VARARGS, NULL},
	 { "aig_bdd2INFvar", _wrap_aig_bdd2INFvar, METH_VARARGS, NULL},
	 { "aig_bdd2ISOPvar", _wrap_aig_bdd2ISOPvar, METH_VARARGS, NULL},
	 { "aig_encode_bdd", _wrap_aig_encode_bdd, METH_VARARGS, NULL},
	 { "aig_set_output", _wrap_aig_set_output, METH_VARARGS, NULL},
	 { "aig_set_next_latch", _wrap_aig_set_next_latch, METH_VARARGS, NULL},
	 { "aig_aig_true", _wrap_aig_aig_true, METH_NOARGS, NULL},
	 { "aig_aig_false", _wrap_aig_aig_false, METH_NOARGS, NULL},
	 { "aig_aig_not", _wrap_aig_aig_not, METH_VARARGS, NULL},
	 { "aig_aig_and", _wrap_aig_aig_and, METH_VARARGS, NULL},
	 { "aig_aig_or", _wrap_aig_aig_or, METH_VARARGS, NULL},
	 { "aig_aig_pos", _wrap_aig_aig_pos, METH_VARARGS, NULL},
	 { "aig_encode_all_bdds", _wrap_aig_encode_all_bdds, METH_VARARGS, NULL},
	 { "aig_parse_aag", _wrap_aig_parse_aag, METH_VARARGS, NULL},
	 { "aig_as_automaton", _wrap_aig_as_automaton, METH_VARARGS, NULL},
	 { "aig_circ_state", _wrap_aig_circ_state, METH_O, NULL},
	 { "aig_circ_state_of", _wrap_aig_circ_state_of, METH_VARARGS, NULL},
	 { "aig_circ_init", _wrap_aig_circ_init, METH_O, NULL},
	 { "aig_circ_step", _wrap_aig_circ_step, METH_VARARGS, NULL},
	 { "aig_swigregister", aig_swigregister, METH_O, NULL},
	 { "aig_swiginit", aig_swiginit, METH_VARARGS, NULL},
	 { "mealy_machine_to_aig", _wrap_mealy_machine_to_aig, METH_VARARGS, NULL},
	 { "mealy_machines_to_aig", _wrap_mealy_machines_to_aig, METH_VARARGS, NULL},
	 { "print_aiger", _wrap_print_aiger, METH_VARARGS, NULL},
	 { "new_outedge_combiner", _wrap_new_outedge_combiner, METH_O, NULL},
	 { "delete_outedge_combiner", _wrap_delete_outedge_combiner, METH_O, NULL},
	 { "outedge_combiner___call__", _wrap_outedge_combiner___call__, METH_VARARGS, NULL},
	 { "outedge_combiner_new_dests", _wrap_outedge_combiner_new_dests, METH_VARARGS, NULL},
	 { "outedge_combiner_swigregister", outedge_combiner_swigregister, METH_O, NULL},
	 { "outedge_combiner_swiginit", outedge_combiner_swiginit, METH_VARARGS, NULL},
	 { "remove_alternation", _wrap_remove_alternation, METH_VARARGS, NULL},
	 { "new_univ_remover_state", _wrap_new_univ_remover_state, METH_VARARGS, NULL},
	 { "univ_remover_state_states", _wrap_univ_remover_state_states, METH_O, NULL},
	 { "univ_remover_state_is_reset", _wrap_univ_remover_state_is_reset, METH_O, NULL},
	 { "delete_univ_remover_state", _wrap_delete_univ_remover_state, METH_O, NULL},
	 { "univ_remover_state_swigregister", univ_remover_state_swigregister, METH_O, NULL},
	 { "univ_remover_state_swiginit", univ_remover_state_swiginit, METH_VARARGS, NULL},
	 { "new_twa_univ_remover", _wrap_new_twa_univ_remover, METH_O, NULL},
	 { "twa_univ_remover_allocate_state_vars", _wrap_twa_univ_remover_allocate_state_vars, METH_O, NULL},
	 { "delete_twa_univ_remover", _wrap_delete_twa_univ_remover, METH_O, NULL},
	 { "twa_univ_remover_swigregister", twa_univ_remover_swigregister, METH_O, NULL},
	 { "twa_univ_remover_swiginit", twa_univ_remover_swiginit, METH_VARARGS, NULL},
	 { "remove_univ_otf", _wrap_remove_univ_otf, METH_O, NULL},
	 { "cleanup_acceptance_here", _wrap_cleanup_acceptance_here, METH_VARARGS, NULL},
	 { "cleanup_acceptance", _wrap_cleanup_acceptance, METH_VARARGS, NULL},
	 { "simplify_acceptance_here", _wrap_simplify_acceptance_here, METH_O, NULL},
	 { "simplify_acceptance", _wrap_simplify_acceptance, METH_O, NULL},
	 { "nca_st_info_clause_num_set", _wrap_nca_st_info_clause_num_set, METH_VARARGS, NULL},
	 { "nca_st_info_clause_num_get", _wrap_nca_st_info_clause_num_get, METH_O, NULL},
	 { "nca_st_info_state_num_set", _wrap_nca_st_info_state_num_set, METH_VARARGS, NULL},
	 { "nca_st_info_state_num_get", _wrap_nca_st_info_state_num_get, METH_O, NULL},
	 { "nca_st_info_all_dst_set", _wrap_nca_st_info_all_dst_set, METH_VARARGS, NULL},
	 { "nca_st_info_all_dst_get", _wrap_nca_st_info_all_dst_get, METH_O, NULL},
	 { "new_nca_st_info", _wrap_new_nca_st_info, METH_VARARGS, NULL},
	 { "delete_nca_st_info", _wrap_delete_nca_st_info, METH_O, NULL},
	 { "nca_st_info_swigregister", nca_st_info_swigregister, METH_O, NULL},
	 { "nca_st_info_swiginit", nca_st_info_swiginit, METH_VARARGS, NULL},
	 { "nsa_to_nca", _wrap_nsa_to_nca, METH_VARARGS, NULL},
	 { "dnf_to_nca", _wrap_dnf_to_nca, METH_VARARGS, NULL},
	 { "to_nca", _wrap_to_nca, METH_VARARGS, NULL},
	 { "nsa_to_dca", _wrap_nsa_to_dca, METH_VARARGS, NULL},
	 { "dnf_to_dca", _wrap_dnf_to_dca, METH_VARARGS, NULL},
	 { "to_dca", _wrap_to_dca, METH_VARARGS, NULL},
	 { "copy", _wrap_copy, METH_VARARGS, NULL},
	 { "complete_here", _wrap_complete_here, METH_O, NULL},
	 { "complete", _wrap_complete, METH_O, NULL},
	 { "delay_branching_here", _wrap_delay_branching_here, METH_O, NULL},
	 { "degeneralize", _wrap_degeneralize, METH_VARARGS, NULL},
	 { "degeneralize_tba", _wrap_degeneralize_tba, METH_VARARGS, NULL},
	 { "partial_degeneralize", _wrap_partial_degeneralize, METH_VARARGS, NULL},
	 { "is_partially_degeneralizable", _wrap_is_partially_degeneralizable, METH_VARARGS, NULL},
	 { "propagate_marks_vector", _wrap_propagate_marks_vector, METH_VARARGS, NULL},
	 { "propagate_marks_here", _wrap_propagate_marks_here, METH_VARARGS, NULL},
	 { "tgba_determinize", _wrap_tgba_determinize, METH_VARARGS, NULL},
	 { "dualize", _wrap_dualize, METH_O, NULL},
	 { "new_emptiness_check_result", _wrap_new_emptiness_check_result, METH_VARARGS, NULL},
	 { "delete_emptiness_check_result", _wrap_delete_emptiness_check_result, METH_O, NULL},
	 { "emptiness_check_result_accepting_run", _wrap_emptiness_check_result_accepting_run, METH_O, NULL},
	 { "emptiness_check_result_automaton", _wrap_emptiness_check_result_automaton, METH_O, NULL},
	 { "emptiness_check_result_options", _wrap_emptiness_check_result_options, METH_O, NULL},
	 { "emptiness_check_result_parse_options", _wrap_emptiness_check_result_parse_options, METH_VARARGS, NULL},
	 { "emptiness_check_result_statistics", _wrap_emptiness_check_result_statistics, METH_O, NULL},
	 { "emptiness_check_result_swigregister", emptiness_check_result_swigregister, METH_O, NULL},
	 { "emptiness_check_result_swiginit", emptiness_check_result_swiginit, METH_VARARGS, NULL},
	 { "delete_emptiness_check", _wrap_delete_emptiness_check, METH_O, NULL},
	 { "emptiness_check_automaton", _wrap_emptiness_check_automaton, METH_O, NULL},
	 { "emptiness_check_options", _wrap_emptiness_check_options, METH_O, NULL},
	 { "emptiness_check_parse_options", _wrap_emptiness_check_parse_options, METH_VARARGS, NULL},
	 { "emptiness_check_safe", _wrap_emptiness_check_safe, METH_O, NULL},
	 { "emptiness_check_check", _wrap_emptiness_check_check, METH_O, NULL},
	 { "emptiness_check_statistics", _wrap_emptiness_check_statistics, METH_O, NULL},
	 { "emptiness_check_emptiness_check_statistics", _wrap_emptiness_check_emptiness_check_statistics, METH_O, NULL},
	 { "emptiness_check_print_stats", _wrap_emptiness_check_print_stats, METH_VARARGS, NULL},
	 { "emptiness_check_options_updated", _wrap_emptiness_check_options_updated, METH_VARARGS, NULL},
	 { "emptiness_check_swigregister", emptiness_check_swigregister, METH_O, NULL},
	 { "emptiness_check_instantiator_instantiate", _wrap_emptiness_check_instantiator_instantiate, METH_VARARGS, NULL},
	 { "emptiness_check_instantiator_options", _wrap_emptiness_check_instantiator_options, METH_VARARGS, NULL},
	 { "emptiness_check_instantiator_min_sets", _wrap_emptiness_check_instantiator_min_sets, METH_O, NULL},
	 { "emptiness_check_instantiator_max_sets", _wrap_emptiness_check_instantiator_max_sets, METH_O, NULL},
	 { "delete_emptiness_check_instantiator", _wrap_delete_emptiness_check_instantiator, METH_O, NULL},
	 { "emptiness_check_instantiator_swigregister", emptiness_check_instantiator_swigregister, METH_O, NULL},
	 { "make_emptiness_check_instantiator", _wrap_make_emptiness_check_instantiator, METH_O, NULL},
	 { "twa_run_prefix_set", _wrap_twa_run_prefix_set, METH_VARARGS, NULL},
	 { "twa_run_prefix_get", _wrap_twa_run_prefix_get, METH_O, NULL},
	 { "twa_run_cycle_set", _wrap_twa_run_cycle_set, METH_VARARGS, NULL},
	 { "twa_run_cycle_get", _wrap_twa_run_cycle_get, METH_O, NULL},
	 { "twa_run_aut_set", _wrap_twa_run_aut_set, METH_VARARGS, NULL},
	 { "twa_run_aut_get", _wrap_twa_run_aut_get, METH_O, NULL},
	 { "delete_twa_run", _wrap_delete_twa_run, METH_O, NULL},
	 { "new_twa_run", _wrap_new_twa_run, METH_VARARGS, NULL},
	 { "twa_run_ensure_non_empty_cycle", _wrap_twa_run_ensure_non_empty_cycle, METH_VARARGS, NULL},
	 { "twa_run_reduce", _wrap_twa_run_reduce, METH_O, NULL},
	 { "twa_run_project", _wrap_twa_run_project, METH_VARARGS, NULL},
	 { "twa_run_replay", _wrap_twa_run_replay, METH_VARARGS, NULL},
	 { "twa_run_highlight", _wrap_twa_run_highlight, METH_VARARGS, NULL},
	 { "twa_run_as_twa", _wrap_twa_run_as_twa, METH_VARARGS, NULL},
	 { "twa_run___str__", _wrap_twa_run___str__, METH_O, NULL},
	 { "twa_run_swigregister", twa_run_swigregister, METH_O, NULL},
	 { "twa_run_swiginit", twa_run_swiginit, METH_VARARGS, NULL},
	 { "step_s_set", _wrap_step_s_set, METH_VARARGS, NULL},
	 { "step_s_get", _wrap_step_s_get, METH_O, NULL},
	 { "step_label_set", _wrap_step_label_set, METH_VARARGS, NULL},
	 { "step_label_get", _wrap_step_label_get, METH_O, NULL},
	 { "step_acc_set", _wrap_step_acc_set, METH_VARARGS, NULL},
	 { "step_acc_get", _wrap_step_acc_get, METH_O, NULL},
	 { "new_step", _wrap_new_step, METH_VARARGS, NULL},
	 { "delete_step", _wrap_delete_step, METH_O, NULL},
	 { "step_swigregister", step_swigregister, METH_O, NULL},
	 { "step_swiginit", step_swiginit, METH_VARARGS, NULL},
	 { "list_step_iterator", _wrap_list_step_iterator, METH_O, NULL},
	 { "list_step___nonzero__", _wrap_list_step___nonzero__, METH_O, NULL},
	 { "list_step___bool__", _wrap_list_step___bool__, METH_O, NULL},
	 { "list_step___len__", _wrap_list_step___len__, METH_O, NULL},
	 { "list_step___getslice__", _wrap_list_step___getslice__, METH_VARARGS, NULL},
	 { "list_step___setslice__", _wrap_list_step___setslice__, METH_VARARGS, NULL},
	 { "list_step___delslice__", _wrap_list_step___delslice__, METH_VARARGS, NULL},
	 { "list_step___delitem__", _wrap_list_step___delitem__, METH_VARARGS, NULL},
	 { "list_step___getitem__", _wrap_list_step___getitem__, METH_VARARGS, NULL},
	 { "list_step___setitem__", _wrap_list_step___setitem__, METH_VARARGS, NULL},
	 { "list_step_pop", _wrap_list_step_pop, METH_O, NULL},
	 { "list_step_append", _wrap_list_step_append, METH_VARARGS, NULL},
	 { "list_step_empty", _wrap_list_step_empty, METH_O, NULL},
	 { "list_step_size", _wrap_list_step_size, METH_O, NULL},
	 { "list_step_swap", _wrap_list_step_swap, METH_VARARGS, NULL},
	 { "list_step_begin", _wrap_list_step_begin, METH_O, NULL},
	 { "list_step_end", _wrap_list_step_end, METH_O, NULL},
	 { "list_step_rbegin", _wrap_list_step_rbegin, METH_O, NULL},
	 { "list_step_rend", _wrap_list_step_rend, METH_O, NULL},
	 { "list_step_clear", _wrap_list_step_clear, METH_O, NULL},
	 { "list_step_get_allocator", _wrap_list_step_get_allocator, METH_O, NULL},
	 { "list_step_pop_back", _wrap_list_step_pop_back, METH_O, NULL},
	 { "list_step_erase", _wrap_list_step_erase, METH_VARARGS, NULL},
	 { "new_list_step", _wrap_new_list_step, METH_VARARGS, NULL},
	 { "list_step_push_back", _wrap_list_step_push_back, METH_VARARGS, NULL},
	 { "list_step_front", _wrap_list_step_front, METH_O, NULL},
	 { "list_step_back", _wrap_list_step_back, METH_O, NULL},
	 { "list_step_assign", _wrap_list_step_assign, METH_VARARGS, NULL},
	 { "list_step_resize", _wrap_list_step_resize, METH_VARARGS, NULL},
	 { "list_step_insert", _wrap_list_step_insert, METH_VARARGS, NULL},
	 { "list_step_pop_front", _wrap_list_step_pop_front, METH_O, NULL},
	 { "list_step_push_front", _wrap_list_step_push_front, METH_VARARGS, NULL},
	 { "list_step_reverse", _wrap_list_step_reverse, METH_O, NULL},
	 { "delete_list_step", _wrap_delete_list_step, METH_O, NULL},
	 { "list_step_swigregister", list_step_swigregister, METH_O, NULL},
	 { "list_step_swiginit", list_step_swiginit, METH_VARARGS, NULL},
	 { "couvreur99", _wrap_couvreur99, METH_VARARGS, NULL},
	 { "generic_emptiness_check", _wrap_generic_emptiness_check, METH_O, NULL},
	 { "generic_accepting_run", _wrap_generic_accepting_run, METH_O, NULL},
	 { "generic_emptiness_check_for_scc", _wrap_generic_emptiness_check_for_scc, METH_VARARGS, NULL},
	 { "generic_emptiness_check_select_version", _wrap_generic_emptiness_check_select_version, METH_VARARGS, NULL},
	 { "accepting_transitions_scc", _wrap_accepting_transitions_scc, METH_VARARGS, NULL},
	 { "accepting_transitions", _wrap_accepting_transitions, METH_VARARGS, NULL},
	 { "print_lbtt", _wrap_print_lbtt, METH_VARARGS, NULL},
	 { "ltl_to_taa", _wrap_ltl_to_taa, METH_VARARGS, NULL},
	 { "ltl_to_tgba_fm", _wrap_ltl_to_tgba_fm, METH_VARARGS, NULL},
	 { "g_f_terminal_inplace", _wrap_g_f_terminal_inplace, METH_VARARGS, NULL},
	 { "gf_guarantee_to_ba_maybe", _wrap_gf_guarantee_to_ba_maybe, METH_VARARGS, NULL},
	 { "gf_guarantee_to_ba", _wrap_gf_guarantee_to_ba, METH_VARARGS, NULL},
	 { "fg_safety_to_dca_maybe", _wrap_fg_safety_to_dca_maybe, METH_VARARGS, NULL},
	 { "fg_safety_to_dca", _wrap_fg_safety_to_dca, METH_VARARGS, NULL},
	 { "compsusp", _wrap_compsusp, METH_VARARGS, NULL},
	 { "contains", _wrap_contains, METH_VARARGS, NULL},
	 { "are_equivalent", _wrap_are_equivalent, METH_VARARGS, NULL},
	 { "language_map", _wrap_language_map, METH_O, NULL},
	 { "highlight_languages", _wrap_highlight_languages, METH_O, NULL},
	 { "explicit_magic_search", _wrap_explicit_magic_search, METH_VARARGS, NULL},
	 { "bit_state_hashing_magic_search", _wrap_bit_state_hashing_magic_search, METH_VARARGS, NULL},
	 { "magic_search", _wrap_magic_search, METH_VARARGS, NULL},
	 { "minimize_monitor", _wrap_minimize_monitor, METH_O, NULL},
	 { "minimize_wdba", _wrap_minimize_wdba, METH_VARARGS, NULL},
	 { "minimize_obligation", _wrap_minimize_obligation, METH_VARARGS, NULL},
	 { "minimize_obligation_garanteed_to_work", _wrap_minimize_obligation_garanteed_to_work, METH_VARARGS, NULL},
	 { "is_mealy", _wrap_is_mealy, METH_O, NULL},
	 { "is_separated_mealy", _wrap_is_separated_mealy, METH_O, NULL},
	 { "is_split_mealy", _wrap_is_split_mealy, METH_O, NULL},
	 { "is_input_deterministic_mealy", _wrap_is_input_deterministic_mealy, METH_O, NULL},
	 { "split_separated_mealy", _wrap_split_separated_mealy, METH_O, NULL},
	 { "split_separated_mealy_here", _wrap_split_separated_mealy_here, METH_O, NULL},
	 { "unsplit_mealy", _wrap_unsplit_mealy, METH_O, NULL},
	 { "reduce_mealy", _wrap_reduce_mealy, METH_VARARGS, NULL},
	 { "reduce_mealy_here", _wrap_reduce_mealy_here, METH_VARARGS, NULL},
	 { "minimize_mealy", _wrap_minimize_mealy, METH_VARARGS, NULL},
	 { "is_split_mealy_specialization", _wrap_is_split_mealy_specialization, METH_VARARGS, NULL},
	 { "mealy_product", _wrap_mealy_product, METH_VARARGS, NULL},
	 { "simplify_mealy_here", _wrap_simplify_mealy_here, METH_VARARGS, NULL},
	 { "print_never_claim", _wrap_print_never_claim, METH_VARARGS, NULL},
	 { "randomize", _wrap_randomize, METH_VARARGS, NULL},
	 { "rabin_is_buchi_realizable", _wrap_rabin_is_buchi_realizable, METH_O, NULL},
	 { "rabin_to_buchi_if_realizable", _wrap_rabin_to_buchi_if_realizable, METH_O, NULL},
	 { "rabin_to_buchi_maybe", _wrap_rabin_to_buchi_maybe, METH_O, NULL},
	 { "remove_fin", _wrap_remove_fin, METH_O, NULL},
	 { "remove_ap_add_ap", _wrap_remove_ap_add_ap, METH_VARARGS, NULL},
	 { "remove_ap_empty", _wrap_remove_ap_empty, METH_O, NULL},
	 { "remove_ap_strip", _wrap_remove_ap_strip, METH_VARARGS, NULL},
	 { "new_remove_ap", _wrap_new_remove_ap, METH_NOARGS, NULL},
	 { "delete_remove_ap", _wrap_delete_remove_ap, METH_O, NULL},
	 { "remove_ap_swigregister", remove_ap_swigregister, METH_O, NULL},
	 { "remove_ap_swiginit", remove_ap_swiginit, METH_VARARGS, NULL},
	 { "to_finite", _wrap_to_finite, METH_VARARGS, NULL},
	 { "to_generalized_buchi", _wrap_to_generalized_buchi, METH_O, NULL},
	 { "streett_to_generalized_buchi", _wrap_streett_to_generalized_buchi, METH_O, NULL},
	 { "streett_to_generalized_buchi_maybe", _wrap_streett_to_generalized_buchi_maybe, METH_O, NULL},
	 { "to_generalized_rabin", _wrap_to_generalized_rabin, METH_VARARGS, NULL},
	 { "to_generalized_streett", _wrap_to_generalized_streett, METH_VARARGS, NULL},
	 { "dnf_to_streett", _wrap_dnf_to_streett, METH_VARARGS, NULL},
	 { "sbacc", _wrap_sbacc, METH_O, NULL},
	 { "new_keep_all", _wrap_new_keep_all, METH_NOARGS, NULL},
	 { "delete_keep_all", _wrap_delete_keep_all, METH_O, NULL},
	 { "keep_all_swigregister", keep_all_swigregister, METH_O, NULL},
	 { "keep_all_swiginit", keep_all_swiginit, METH_VARARGS, NULL},
	 { "new_keep_inner_scc", _wrap_new_keep_inner_scc, METH_VARARGS, NULL},
	 { "delete_keep_inner_scc", _wrap_delete_keep_inner_scc, METH_O, NULL},
	 { "keep_inner_scc_swigregister", keep_inner_scc_swigregister, METH_O, NULL},
	 { "keep_inner_scc_swiginit", keep_inner_scc_swiginit, METH_VARARGS, NULL},
	 { "new_scc_info_node", _wrap_new_scc_info_node, METH_VARARGS, NULL},
	 { "scc_info_node_is_trivial", _wrap_scc_info_node_is_trivial, METH_O, NULL},
	 { "scc_info_node_is_accepting", _wrap_scc_info_node_is_accepting, METH_O, NULL},
	 { "scc_info_node_is_rejecting", _wrap_scc_info_node_is_rejecting, METH_O, NULL},
	 { "scc_info_node_is_useful", _wrap_scc_info_node_is_useful, METH_O, NULL},
	 { "scc_info_node_acc_marks", _wrap_scc_info_node_acc_marks, METH_O, NULL},
	 { "scc_info_node_common_marks", _wrap_scc_info_node_common_marks, METH_O, NULL},
	 { "scc_info_node_states", _wrap_scc_info_node_states, METH_O, NULL},
	 { "scc_info_node_one_state", _wrap_scc_info_node_one_state, METH_O, NULL},
	 { "scc_info_node_succ", _wrap_scc_info_node_succ, METH_O, NULL},
	 { "delete_scc_info_node", _wrap_delete_scc_info_node, METH_O, NULL},
	 { "scc_info_node_swigregister", scc_info_node_swigregister, METH_O, NULL},
	 { "scc_info_node_swiginit", scc_info_node_swiginit, METH_VARARGS, NULL},
	 { "__and__", _wrap___and__, METH_VARARGS, NULL},
	 { "__or__", _wrap___or__, METH_VARARGS, NULL},
	 { "new_scc_info_with_options", _wrap_new_scc_info_with_options, METH_VARARGS, NULL},
	 { "new_scc_info", _wrap_new_scc_info, METH_VARARGS, NULL},
	 { "scc_info_get_aut", _wrap_scc_info_get_aut, METH_O, NULL},
	 { "scc_info_get_options", _wrap_scc_info_get_options, METH_O, NULL},
	 { "scc_info_get_filter", _wrap_scc_info_get_filter, METH_O, NULL},
	 { "scc_info_get_filter_data", _wrap_scc_info_get_filter_data, METH_O, NULL},
	 { "scc_info_scc_count", _wrap_scc_info_scc_count, METH_O, NULL},
	 { "scc_info_one_accepting_scc", _wrap_scc_info_one_accepting_scc, METH_O, NULL},
	 { "scc_info_reachable_state", _wrap_scc_info_reachable_state, METH_VARARGS, NULL},
	 { "scc_info_scc_of", _wrap_scc_info_scc_of, METH_VARARGS, NULL},
	 { "scc_info_begin", _wrap_scc_info_begin, METH_O, NULL},
	 { "scc_info_end", _wrap_scc_info_end, METH_O, NULL},
	 { "scc_info_cbegin", _wrap_scc_info_cbegin, METH_O, NULL},
	 { "scc_info_cend", _wrap_scc_info_cend, METH_O, NULL},
	 { "scc_info_rbegin", _wrap_scc_info_rbegin, METH_O, NULL},
	 { "scc_info_rend", _wrap_scc_info_rend, METH_O, NULL},
	 { "scc_info_states_of", _wrap_scc_info_states_of, METH_VARARGS, NULL},
	 { "scc_info_edges_of", _wrap_scc_info_edges_of, METH_VARARGS, NULL},
	 { "scc_info_inner_edges_of", _wrap_scc_info_inner_edges_of, METH_VARARGS, NULL},
	 { "scc_info_one_state_of", _wrap_scc_info_one_state_of, METH_VARARGS, NULL},
	 { "scc_info_initial", _wrap_scc_info_initial, METH_O, NULL},
	 { "scc_info_succ", _wrap_scc_info_succ, METH_VARARGS, NULL},
	 { "scc_info_is_trivial", _wrap_scc_info_is_trivial, METH_VARARGS, NULL},
	 { "scc_info_acc", _wrap_scc_info_acc, METH_VARARGS, NULL},
	 { "scc_info_is_accepting_scc", _wrap_scc_info_is_accepting_scc, METH_VARARGS, NULL},
	 { "scc_info_is_rejecting_scc", _wrap_scc_info_is_rejecting_scc, METH_VARARGS, NULL},
	 { "scc_info_is_maximally_accepting_scc", _wrap_scc_info_is_maximally_accepting_scc, METH_VARARGS, NULL},
	 { "scc_info_determine_unknown_acceptance", _wrap_scc_info_determine_unknown_acceptance, METH_O, NULL},
	 { "scc_info_check_scc_emptiness", _wrap_scc_info_check_scc_emptiness, METH_VARARGS, NULL},
	 { "scc_info_get_accepting_run", _wrap_scc_info_get_accepting_run, METH_VARARGS, NULL},
	 { "scc_info_is_useful_scc", _wrap_scc_info_is_useful_scc, METH_VARARGS, NULL},
	 { "scc_info_is_useful_state", _wrap_scc_info_is_useful_state, METH_VARARGS, NULL},
	 { "scc_info_marks", _wrap_scc_info_marks, METH_O, NULL},
	 { "scc_info_marks_of", _wrap_scc_info_marks_of, METH_VARARGS, NULL},
	 { "scc_info_used_acc", _wrap_scc_info_used_acc, METH_O, NULL},
	 { "scc_info_used_acc_of", _wrap_scc_info_used_acc_of, METH_VARARGS, NULL},
	 { "scc_info_acc_sets_of", _wrap_scc_info_acc_sets_of, METH_VARARGS, NULL},
	 { "scc_info_common_sets_of", _wrap_scc_info_common_sets_of, METH_VARARGS, NULL},
	 { "scc_info_weak_sccs", _wrap_scc_info_weak_sccs, METH_O, NULL},
	 { "scc_info_scc_ap_support", _wrap_scc_info_scc_ap_support, METH_VARARGS, NULL},
	 { "scc_info_split_on_sets", _wrap_scc_info_split_on_sets, METH_VARARGS, NULL},
	 { "scc_info_states_on_acc_cycle_of", _wrap_scc_info_states_on_acc_cycle_of, METH_VARARGS, NULL},
	 { "scc_info___iter__", _wrap_scc_info___iter__, METH_O, NULL},
	 { "delete_scc_info", _wrap_delete_scc_info, METH_O, NULL},
	 { "scc_info_swigregister", scc_info_swigregister, METH_O, NULL},
	 { "scc_info_swiginit", scc_info_swiginit, METH_VARARGS, NULL},
	 { "new_scc_and_mark_filter", _wrap_new_scc_and_mark_filter, METH_VARARGS, NULL},
	 { "delete_scc_and_mark_filter", _wrap_delete_scc_and_mark_filter, METH_O, NULL},
	 { "scc_and_mark_filter_override_acceptance", _wrap_scc_and_mark_filter_override_acceptance, METH_VARARGS, NULL},
	 { "scc_and_mark_filter_restore_acceptance", _wrap_scc_and_mark_filter_restore_acceptance, METH_O, NULL},
	 { "scc_and_mark_filter_get_aut", _wrap_scc_and_mark_filter_get_aut, METH_O, NULL},
	 { "scc_and_mark_filter_start_state", _wrap_scc_and_mark_filter_start_state, METH_O, NULL},
	 { "scc_and_mark_filter_get_filter", _wrap_scc_and_mark_filter_get_filter, METH_O, NULL},
	 { "scc_and_mark_filter_swigregister", scc_and_mark_filter_swigregister, METH_O, NULL},
	 { "scc_and_mark_filter_swiginit", scc_and_mark_filter_swiginit, METH_VARARGS, NULL},
	 { "dump_scc_info_dot", _wrap_dump_scc_info_dot, METH_VARARGS, NULL},
	 { "new_scc_info_scc_edges", _wrap_new_scc_info_scc_edges, METH_VARARGS, NULL},
	 { "scc_info_scc_edges_begin", _wrap_scc_info_scc_edges_begin, METH_O, NULL},
	 { "scc_info_scc_edges_end", _wrap_scc_info_scc_edges_end, METH_O, NULL},
	 { "scc_info_scc_edges___iter__", _wrap_scc_info_scc_edges___iter__, METH_O, NULL},
	 { "delete_scc_info_scc_edges", _wrap_delete_scc_info_scc_edges, METH_O, NULL},
	 { "scc_info_scc_edges_swigregister", scc_info_scc_edges_swigregister, METH_O, NULL},
	 { "scc_info_scc_edges_swiginit", scc_info_scc_edges_swiginit, METH_VARARGS, NULL},
	 { "new_scc_info_inner_scc_edges", _wrap_new_scc_info_inner_scc_edges, METH_VARARGS, NULL},
	 { "scc_info_inner_scc_edges_begin", _wrap_scc_info_inner_scc_edges_begin, METH_O, NULL},
	 { "scc_info_inner_scc_edges_end", _wrap_scc_info_inner_scc_edges_end, METH_O, NULL},
	 { "scc_info_inner_scc_edges___iter__", _wrap_scc_info_inner_scc_edges___iter__, METH_O, NULL},
	 { "delete_scc_info_inner_scc_edges", _wrap_delete_scc_info_inner_scc_edges, METH_O, NULL},
	 { "scc_info_inner_scc_edges_swigregister", scc_info_inner_scc_edges_swigregister, METH_O, NULL},
	 { "scc_info_inner_scc_edges_swiginit", scc_info_inner_scc_edges_swiginit, METH_VARARGS, NULL},
	 { "vector_twa_graph_iterator", _wrap_vector_twa_graph_iterator, METH_O, NULL},
	 { "vector_twa_graph___nonzero__", _wrap_vector_twa_graph___nonzero__, METH_O, NULL},
	 { "vector_twa_graph___bool__", _wrap_vector_twa_graph___bool__, METH_O, NULL},
	 { "vector_twa_graph___len__", _wrap_vector_twa_graph___len__, METH_O, NULL},
	 { "vector_twa_graph___getslice__", _wrap_vector_twa_graph___getslice__, METH_VARARGS, NULL},
	 { "vector_twa_graph___setslice__", _wrap_vector_twa_graph___setslice__, METH_VARARGS, NULL},
	 { "vector_twa_graph___delslice__", _wrap_vector_twa_graph___delslice__, METH_VARARGS, NULL},
	 { "vector_twa_graph___delitem__", _wrap_vector_twa_graph___delitem__, METH_VARARGS, NULL},
	 { "vector_twa_graph___getitem__", _wrap_vector_twa_graph___getitem__, METH_VARARGS, NULL},
	 { "vector_twa_graph___setitem__", _wrap_vector_twa_graph___setitem__, METH_VARARGS, NULL},
	 { "vector_twa_graph_pop", _wrap_vector_twa_graph_pop, METH_O, NULL},
	 { "vector_twa_graph_append", _wrap_vector_twa_graph_append, METH_VARARGS, NULL},
	 { "vector_twa_graph_empty", _wrap_vector_twa_graph_empty, METH_O, NULL},
	 { "vector_twa_graph_size", _wrap_vector_twa_graph_size, METH_O, NULL},
	 { "vector_twa_graph_swap", _wrap_vector_twa_graph_swap, METH_VARARGS, NULL},
	 { "vector_twa_graph_begin", _wrap_vector_twa_graph_begin, METH_O, NULL},
	 { "vector_twa_graph_end", _wrap_vector_twa_graph_end, METH_O, NULL},
	 { "vector_twa_graph_rbegin", _wrap_vector_twa_graph_rbegin, METH_O, NULL},
	 { "vector_twa_graph_rend", _wrap_vector_twa_graph_rend, METH_O, NULL},
	 { "vector_twa_graph_clear", _wrap_vector_twa_graph_clear, METH_O, NULL},
	 { "vector_twa_graph_get_allocator", _wrap_vector_twa_graph_get_allocator, METH_O, NULL},
	 { "vector_twa_graph_pop_back", _wrap_vector_twa_graph_pop_back, METH_O, NULL},
	 { "vector_twa_graph_erase", _wrap_vector_twa_graph_erase, METH_VARARGS, NULL},
	 { "new_vector_twa_graph", _wrap_new_vector_twa_graph, METH_VARARGS, NULL},
	 { "vector_twa_graph_push_back", _wrap_vector_twa_graph_push_back, METH_VARARGS, NULL},
	 { "vector_twa_graph_front", _wrap_vector_twa_graph_front, METH_O, NULL},
	 { "vector_twa_graph_back", _wrap_vector_twa_graph_back, METH_O, NULL},
	 { "vector_twa_graph_assign", _wrap_vector_twa_graph_assign, METH_VARARGS, NULL},
	 { "vector_twa_graph_resize", _wrap_vector_twa_graph_resize, METH_VARARGS, NULL},
	 { "vector_twa_graph_insert", _wrap_vector_twa_graph_insert, METH_VARARGS, NULL},
	 { "vector_twa_graph_reserve", _wrap_vector_twa_graph_reserve, METH_VARARGS, NULL},
	 { "vector_twa_graph_capacity", _wrap_vector_twa_graph_capacity, METH_O, NULL},
	 { "delete_vector_twa_graph", _wrap_delete_vector_twa_graph, METH_O, NULL},
	 { "vector_twa_graph_swigregister", vector_twa_graph_swigregister, METH_O, NULL},
	 { "vector_twa_graph_swiginit", vector_twa_graph_swiginit, METH_VARARGS, NULL},
	 { "is_terminal_automaton", _wrap_is_terminal_automaton, METH_VARARGS, NULL},
	 { "is_weak_automaton", _wrap_is_weak_automaton, METH_VARARGS, NULL},
	 { "is_very_weak_automaton", _wrap_is_very_weak_automaton, METH_VARARGS, NULL},
	 { "is_inherently_weak_automaton", _wrap_is_inherently_weak_automaton, METH_VARARGS, NULL},
	 { "is_safety_automaton", _wrap_is_safety_automaton, METH_VARARGS, NULL},
	 { "is_liveness_automaton", _wrap_is_liveness_automaton, METH_O, NULL},
	 { "check_strength", _wrap_check_strength, METH_VARARGS, NULL},
	 { "decompose_strength", _wrap_decompose_strength, METH_VARARGS, NULL},
	 { "decompose_scc", _wrap_decompose_scc, METH_VARARGS, NULL},
	 { "scc_filter", _wrap_scc_filter, METH_VARARGS, NULL},
	 { "scc_filter_states", _wrap_scc_filter_states, METH_VARARGS, NULL},
	 { "scc_filter_susp", _wrap_scc_filter_susp, METH_VARARGS, NULL},
	 { "twa_statistics_edges_set", _wrap_twa_statistics_edges_set, METH_VARARGS, NULL},
	 { "twa_statistics_edges_get", _wrap_twa_statistics_edges_get, METH_O, NULL},
	 { "twa_statistics_states_set", _wrap_twa_statistics_states_set, METH_VARARGS, NULL},
	 { "twa_statistics_states_get", _wrap_twa_statistics_states_get, METH_O, NULL},
	 { "new_twa_statistics", _wrap_new_twa_statistics, METH_NOARGS, NULL},
	 { "twa_statistics_dump", _wrap_twa_statistics_dump, METH_VARARGS, NULL},
	 { "delete_twa_statistics", _wrap_delete_twa_statistics, METH_O, NULL},
	 { "twa_statistics_swigregister", twa_statistics_swigregister, METH_O, NULL},
	 { "twa_statistics_swiginit", twa_statistics_swiginit, METH_VARARGS, NULL},
	 { "twa_sub_statistics_transitions_set", _wrap_twa_sub_statistics_transitions_set, METH_VARARGS, NULL},
	 { "twa_sub_statistics_transitions_get", _wrap_twa_sub_statistics_transitions_get, METH_O, NULL},
	 { "new_twa_sub_statistics", _wrap_new_twa_sub_statistics, METH_NOARGS, NULL},
	 { "twa_sub_statistics_dump", _wrap_twa_sub_statistics_dump, METH_VARARGS, NULL},
	 { "delete_twa_sub_statistics", _wrap_delete_twa_sub_statistics, METH_O, NULL},
	 { "twa_sub_statistics_swigregister", twa_sub_statistics_swigregister, METH_O, NULL},
	 { "twa_sub_statistics_swiginit", twa_sub_statistics_swiginit, METH_VARARGS, NULL},
	 { "sub_stats_reachable", _wrap_sub_stats_reachable, METH_O, NULL},
	 { "count_all_transitions", _wrap_count_all_transitions, METH_O, NULL},
	 { "printable_formula__print", _wrap_printable_formula__print, METH_VARARGS, NULL},
	 { "new_printable_formula", _wrap_new_printable_formula, METH_NOARGS, NULL},
	 { "delete_printable_formula", _wrap_delete_printable_formula, METH_O, NULL},
	 { "printable_formula_swigregister", printable_formula_swigregister, METH_O, NULL},
	 { "printable_formula_swiginit", printable_formula_swiginit, METH_VARARGS, NULL},
	 { "printable_acc_cond__print", _wrap_printable_acc_cond__print, METH_VARARGS, NULL},
	 { "new_printable_acc_cond", _wrap_new_printable_acc_cond, METH_NOARGS, NULL},
	 { "delete_printable_acc_cond", _wrap_delete_printable_acc_cond, METH_O, NULL},
	 { "printable_acc_cond_swigregister", printable_acc_cond_swigregister, METH_O, NULL},
	 { "printable_acc_cond_swiginit", printable_acc_cond_swiginit, METH_VARARGS, NULL},
	 { "printable_scc_info_automaton", _wrap_printable_scc_info_automaton, METH_VARARGS, NULL},
	 { "printable_scc_info_reset", _wrap_printable_scc_info_reset, METH_O, NULL},
	 { "printable_scc_info__print", _wrap_printable_scc_info__print, METH_VARARGS, NULL},
	 { "new_printable_scc_info", _wrap_new_printable_scc_info, METH_NOARGS, NULL},
	 { "delete_printable_scc_info", _wrap_delete_printable_scc_info, METH_O, NULL},
	 { "printable_scc_info_swigregister", printable_scc_info_swigregister, METH_O, NULL},
	 { "printable_scc_info_swiginit", printable_scc_info_swiginit, METH_VARARGS, NULL},
	 { "printable_size_set", _wrap_printable_size_set, METH_VARARGS, NULL},
	 { "printable_size__print", _wrap_printable_size__print, METH_VARARGS, NULL},
	 { "new_printable_size", _wrap_new_printable_size, METH_NOARGS, NULL},
	 { "delete_printable_size", _wrap_delete_printable_size, METH_O, NULL},
	 { "printable_size_swigregister", printable_size_swigregister, METH_O, NULL},
	 { "printable_size_swiginit", printable_size_swiginit, METH_VARARGS, NULL},
	 { "printable_long_size_set", _wrap_printable_long_size_set, METH_VARARGS, NULL},
	 { "printable_long_size__print", _wrap_printable_long_size__print, METH_VARARGS, NULL},
	 { "new_printable_long_size", _wrap_new_printable_long_size, METH_NOARGS, NULL},
	 { "delete_printable_long_size", _wrap_delete_printable_long_size, METH_O, NULL},
	 { "printable_long_size_swigregister", printable_long_size_swigregister, METH_O, NULL},
	 { "printable_long_size_swiginit", printable_long_size_swiginit, METH_VARARGS, NULL},
	 { "new_stat_printer", _wrap_new_stat_printer, METH_VARARGS, NULL},
	 { "stat_printer__print", _wrap_stat_printer__print, METH_VARARGS, NULL},
	 { "delete_stat_printer", _wrap_delete_stat_printer, METH_O, NULL},
	 { "stat_printer_swigregister", stat_printer_swigregister, METH_O, NULL},
	 { "stat_printer_swiginit", stat_printer_swiginit, METH_VARARGS, NULL},
	 { "count_nondet_states", _wrap_count_nondet_states, METH_O, NULL},
	 { "is_universal", _wrap_is_universal, METH_O, NULL},
	 { "is_deterministic", _wrap_is_deterministic, METH_O, NULL},
	 { "highlight_nondet_states", _wrap_highlight_nondet_states, METH_VARARGS, NULL},
	 { "highlight_nondet_edges", _wrap_highlight_nondet_edges, METH_VARARGS, NULL},
	 { "highlight_semidet_sccs", _wrap_highlight_semidet_sccs, METH_VARARGS, NULL},
	 { "is_complete", _wrap_is_complete, METH_O, NULL},
	 { "is_semi_deterministic", _wrap_is_semi_deterministic, METH_O, NULL},
	 { "semidet_sccs", _wrap_semidet_sccs, METH_O, NULL},
	 { "check_determinism", _wrap_check_determinism, METH_O, NULL},
	 { "count_univbranch_states", _wrap_count_univbranch_states, METH_O, NULL},
	 { "count_univbranch_edges", _wrap_count_univbranch_edges, METH_O, NULL},
	 { "is_colored", _wrap_is_colored, METH_O, NULL},
	 { "is_unambiguous", _wrap_is_unambiguous, METH_O, NULL},
	 { "check_unambiguous", _wrap_check_unambiguous, METH_O, NULL},
	 { "scc_has_rejecting_cycle", _wrap_scc_has_rejecting_cycle, METH_VARARGS, NULL},
	 { "is_inherently_weak_scc", _wrap_is_inherently_weak_scc, METH_VARARGS, NULL},
	 { "is_weak_scc", _wrap_is_weak_scc, METH_VARARGS, NULL},
	 { "is_complete_scc", _wrap_is_complete_scc, METH_VARARGS, NULL},
	 { "is_terminal_scc", _wrap_is_terminal_scc, METH_VARARGS, NULL},
	 { "alternate_players", _wrap_alternate_players, METH_VARARGS, NULL},
	 { "solve_parity_game", _wrap_solve_parity_game, METH_O, NULL},
	 { "solve_safety_game", _wrap_solve_safety_game, METH_O, NULL},
	 { "print_pg", _wrap_print_pg, METH_VARARGS, NULL},
	 { "pg_print", _wrap_pg_print, METH_VARARGS, NULL},
	 { "highlight_strategy", _wrap_highlight_strategy, METH_VARARGS, NULL},
	 { "set_state_players", _wrap_set_state_players, METH_VARARGS, NULL},
	 { "set_state_player", _wrap_set_state_player, METH_VARARGS, NULL},
	 { "get_state_player", _wrap_get_state_player, METH_VARARGS, NULL},
	 { "get_state_players", _wrap_get_state_players, METH_VARARGS, NULL},
	 { "get_strategy", _wrap_get_strategy, METH_O, NULL},
	 { "set_strategy", _wrap_set_strategy, METH_VARARGS, NULL},
	 { "set_synthesis_outputs", _wrap_set_synthesis_outputs, METH_VARARGS, NULL},
	 { "get_synthesis_outputs", _wrap_get_synthesis_outputs, METH_O, NULL},
	 { "get_synthesis_output_aps", _wrap_get_synthesis_output_aps, METH_O, NULL},
	 { "set_state_winners", _wrap_set_state_winners, METH_VARARGS, NULL},
	 { "set_state_winner", _wrap_set_state_winner, METH_VARARGS, NULL},
	 { "get_state_winner", _wrap_get_state_winner, METH_VARARGS, NULL},
	 { "get_state_winners", _wrap_get_state_winners, METH_O, NULL},
	 { "simulation", _wrap_simulation, METH_VARARGS, NULL},
	 { "simulation_sba", _wrap_simulation_sba, METH_VARARGS, NULL},
	 { "cosimulation", _wrap_cosimulation, METH_VARARGS, NULL},
	 { "cosimulation_sba", _wrap_cosimulation_sba, METH_VARARGS, NULL},
	 { "iterated_simulations", _wrap_iterated_simulations, METH_VARARGS, NULL},
	 { "iterated_simulations_sba", _wrap_iterated_simulations_sba, METH_VARARGS, NULL},
	 { "reduce_direct_sim", _wrap_reduce_direct_sim, METH_O, NULL},
	 { "reduce_direct_sim_sba", _wrap_reduce_direct_sim_sba, METH_O, NULL},
	 { "reduce_direct_cosim", _wrap_reduce_direct_cosim, METH_O, NULL},
	 { "reduce_direct_cosim_sba", _wrap_reduce_direct_cosim_sba, METH_O, NULL},
	 { "reduce_iterated", _wrap_reduce_iterated, METH_O, NULL},
	 { "reduce_iterated_sba", _wrap_reduce_iterated_sba, METH_O, NULL},
	 { "change_parity", _wrap_change_parity, METH_VARARGS, NULL},
	 { "change_parity_here", _wrap_change_parity_here, METH_VARARGS, NULL},
	 { "cleanup_parity", _wrap_cleanup_parity, METH_VARARGS, NULL},
	 { "cleanup_parity_here", _wrap_cleanup_parity_here, METH_VARARGS, NULL},
	 { "colorize_parity", _wrap_colorize_parity, METH_VARARGS, NULL},
	 { "colorize_parity_here", _wrap_colorize_parity_here, METH_VARARGS, NULL},
	 { "reduce_parity", _wrap_reduce_parity, METH_VARARGS, NULL},
	 { "reduce_parity_here", _wrap_reduce_parity_here, METH_VARARGS, NULL},
	 { "reduce_parity_data_parity_max_set", _wrap_reduce_parity_data_parity_max_set, METH_VARARGS, NULL},
	 { "reduce_parity_data_parity_max_get", _wrap_reduce_parity_data_parity_max_get, METH_O, NULL},
	 { "reduce_parity_data_parity_odd_set", _wrap_reduce_parity_data_parity_odd_set, METH_VARARGS, NULL},
	 { "reduce_parity_data_parity_odd_get", _wrap_reduce_parity_data_parity_odd_get, METH_O, NULL},
	 { "reduce_parity_data_piprime1_set", _wrap_reduce_parity_data_piprime1_set, METH_VARARGS, NULL},
	 { "reduce_parity_data_piprime1_get", _wrap_reduce_parity_data_piprime1_get, METH_O, NULL},
	 { "reduce_parity_data_piprime2_set", _wrap_reduce_parity_data_piprime2_set, METH_VARARGS, NULL},
	 { "reduce_parity_data_piprime2_get", _wrap_reduce_parity_data_piprime2_get, METH_O, NULL},
	 { "new_reduce_parity_data", _wrap_new_reduce_parity_data, METH_VARARGS, NULL},
	 { "delete_reduce_parity_data", _wrap_delete_reduce_parity_data, METH_O, NULL},
	 { "reduce_parity_data_swigregister", reduce_parity_data_swigregister, METH_O, NULL},
	 { "reduce_parity_data_swiginit", reduce_parity_data_swiginit, METH_VARARGS, NULL},
	 { "new_postprocessor", _wrap_new_postprocessor, METH_VARARGS, NULL},
	 { "postprocessor_set_type", _wrap_postprocessor_set_type, METH_VARARGS, NULL},
	 { "postprocessor_set_pref", _wrap_postprocessor_set_pref, METH_VARARGS, NULL},
	 { "postprocessor_set_level", _wrap_postprocessor_set_level, METH_VARARGS, NULL},
	 { "postprocessor_run", _wrap_postprocessor_run, METH_VARARGS, NULL},
	 { "delete_postprocessor", _wrap_delete_postprocessor, METH_O, NULL},
	 { "postprocessor_swigregister", postprocessor_swigregister, METH_O, NULL},
	 { "postprocessor_swiginit", postprocessor_swiginit, METH_VARARGS, NULL},
	 { "power_map_map__set", _wrap_power_map_map__set, METH_VARARGS, NULL},
	 { "power_map_map__get", _wrap_power_map_map__get, METH_O, NULL},
	 { "power_map_states_of", _wrap_power_map_states_of, METH_VARARGS, NULL},
	 { "new_power_map", _wrap_new_power_map, METH_NOARGS, NULL},
	 { "delete_power_map", _wrap_delete_power_map, METH_O, NULL},
	 { "power_map_swigregister", power_map_swigregister, METH_O, NULL},
	 { "power_map_swiginit", power_map_swiginit, METH_VARARGS, NULL},
	 { "new_output_aborter", _wrap_new_output_aborter, METH_VARARGS, NULL},
	 { "output_aborter_max_states", _wrap_output_aborter_max_states, METH_O, NULL},
	 { "output_aborter_max_edges", _wrap_output_aborter_max_edges, METH_O, NULL},
	 { "output_aborter_too_large", _wrap_output_aborter_too_large, METH_VARARGS, NULL},
	 { "output_aborter_print_reason", _wrap_output_aborter_print_reason, METH_VARARGS, NULL},
	 { "delete_output_aborter", _wrap_delete_output_aborter, METH_O, NULL},
	 { "output_aborter_swigregister", output_aborter_swigregister, METH_O, NULL},
	 { "output_aborter_swiginit", output_aborter_swiginit, METH_VARARGS, NULL},
	 { "tgba_powerset", _wrap_tgba_powerset, METH_VARARGS, NULL},
	 { "tba_determinize", _wrap_tba_determinize, METH_VARARGS, NULL},
	 { "tba_determinize_check", _wrap_tba_determinize_check, METH_VARARGS, NULL},
	 { "product", _wrap_product, METH_VARARGS, NULL},
	 { "product_or", _wrap_product_or, METH_VARARGS, NULL},
	 { "product_xor", _wrap_product_xor, METH_VARARGS, NULL},
	 { "product_xnor", _wrap_product_xnor, METH_VARARGS, NULL},
	 { "product_susp", _wrap_product_susp, METH_VARARGS, NULL},
	 { "product_or_susp", _wrap_product_or_susp, METH_VARARGS, NULL},
	 { "split_edges", _wrap_split_edges, METH_O, NULL},
	 { "sum", _wrap_sum, METH_VARARGS, NULL},
	 { "sum_and", _wrap_sum_and, METH_VARARGS, NULL},
	 { "sl", _wrap_sl, METH_O, NULL},
	 { "sl2_inplace", _wrap_sl2_inplace, METH_O, NULL},
	 { "sl2", _wrap_sl2, METH_O, NULL},
	 { "closure_inplace", _wrap_closure_inplace, METH_O, NULL},
	 { "closure", _wrap_closure, METH_O, NULL},
	 { "is_stutter_invariant", _wrap_is_stutter_invariant, METH_VARARGS, NULL},
	 { "check_stutter_invariance", _wrap_check_stutter_invariance, METH_VARARGS, NULL},
	 { "stutter_invariant_states", _wrap_stutter_invariant_states, METH_VARARGS, NULL},
	 { "highlight_stutter_invariant_states", _wrap_highlight_stutter_invariant_states, METH_VARARGS, NULL},
	 { "stutter_invariant_letters", _wrap_stutter_invariant_letters, METH_VARARGS, NULL},
	 { "is_stutter_invariant_forward_closed", _wrap_is_stutter_invariant_forward_closed, METH_VARARGS, NULL},
	 { "make_stutter_invariant_forward_closed_inplace", _wrap_make_stutter_invariant_forward_closed_inplace, METH_VARARGS, NULL},
	 { "split_2step", _wrap_split_2step, METH_VARARGS, NULL},
	 { "unsplit_2step", _wrap_unsplit_2step, METH_O, NULL},
	 { "new_synthesis_info", _wrap_new_synthesis_info, METH_NOARGS, NULL},
	 { "synthesis_info_force_sbacc_set", _wrap_synthesis_info_force_sbacc_set, METH_VARARGS, NULL},
	 { "synthesis_info_force_sbacc_get", _wrap_synthesis_info_force_sbacc_get, METH_O, NULL},
	 { "synthesis_info_s_set", _wrap_synthesis_info_s_set, METH_VARARGS, NULL},
	 { "synthesis_info_s_get", _wrap_synthesis_info_s_get, METH_O, NULL},
	 { "synthesis_info_minimize_lvl_set", _wrap_synthesis_info_minimize_lvl_set, METH_VARARGS, NULL},
	 { "synthesis_info_minimize_lvl_get", _wrap_synthesis_info_minimize_lvl_get, METH_O, NULL},
	 { "synthesis_info_bv_set", _wrap_synthesis_info_bv_set, METH_VARARGS, NULL},
	 { "synthesis_info_bv_get", _wrap_synthesis_info_bv_get, METH_O, NULL},
	 { "synthesis_info_verbose_stream_set", _wrap_synthesis_info_verbose_stream_set, METH_VARARGS, NULL},
	 { "synthesis_info_verbose_stream_get", _wrap_synthesis_info_verbose_stream_get, METH_O, NULL},
	 { "synthesis_info_opt_set", _wrap_synthesis_info_opt_set, METH_VARARGS, NULL},
	 { "synthesis_info_opt_get", _wrap_synthesis_info_opt_get, METH_O, NULL},
	 { "synthesis_info_dict_set", _wrap_synthesis_info_dict_set, METH_VARARGS, NULL},
	 { "synthesis_info_dict_get", _wrap_synthesis_info_dict_get, METH_O, NULL},
	 { "delete_synthesis_info", _wrap_delete_synthesis_info, METH_O, NULL},
	 { "synthesis_info_swigregister", synthesis_info_swigregister, METH_O, NULL},
	 { "synthesis_info_swiginit", synthesis_info_swiginit, METH_VARARGS, NULL},
	 { "__lshift__", _wrap___lshift__, METH_VARARGS, NULL},
	 { "ltl_to_game", _wrap_ltl_to_game, METH_VARARGS, NULL},
	 { "solved_game_to_mealy", _wrap_solved_game_to_mealy, METH_VARARGS, NULL},
	 { "solved_game_to_separated_mealy", _wrap_solved_game_to_separated_mealy, METH_VARARGS, NULL},
	 { "solved_game_to_split_mealy", _wrap_solved_game_to_split_mealy, METH_VARARGS, NULL},
	 { "mealy_like_success_set", _wrap_mealy_like_success_set, METH_VARARGS, NULL},
	 { "mealy_like_success_get", _wrap_mealy_like_success_get, METH_O, NULL},
	 { "mealy_like_mealy_like_set", _wrap_mealy_like_mealy_like_set, METH_VARARGS, NULL},
	 { "mealy_like_mealy_like_get", _wrap_mealy_like_mealy_like_get, METH_O, NULL},
	 { "mealy_like_glob_cond_set", _wrap_mealy_like_glob_cond_set, METH_VARARGS, NULL},
	 { "mealy_like_glob_cond_get", _wrap_mealy_like_glob_cond_get, METH_O, NULL},
	 { "delete_mealy_like", _wrap_delete_mealy_like, METH_O, NULL},
	 { "mealy_like_swigregister", mealy_like_swigregister, METH_O, NULL},
	 { "split_independant_formulas", _wrap_split_independant_formulas, METH_VARARGS, NULL},
	 { "try_create_direct_strategy", _wrap_try_create_direct_strategy, METH_VARARGS, NULL},
	 { "solve_game", _wrap_solve_game, METH_VARARGS, NULL},
	 { "game_relabeling_map_env_map_set", _wrap_game_relabeling_map_env_map_set, METH_VARARGS, NULL},
	 { "game_relabeling_map_env_map_get", _wrap_game_relabeling_map_env_map_get, METH_O, NULL},
	 { "game_relabeling_map_player_map_set", _wrap_game_relabeling_map_player_map_set, METH_VARARGS, NULL},
	 { "game_relabeling_map_player_map_get", _wrap_game_relabeling_map_player_map_get, METH_O, NULL},
	 { "new_game_relabeling_map", _wrap_new_game_relabeling_map, METH_NOARGS, NULL},
	 { "delete_game_relabeling_map", _wrap_delete_game_relabeling_map, METH_O, NULL},
	 { "game_relabeling_map_swigregister", game_relabeling_map_swigregister, METH_O, NULL},
	 { "game_relabeling_map_swiginit", game_relabeling_map_swiginit, METH_VARARGS, NULL},
	 { "partitioned_game_relabel_here", _wrap_partitioned_game_relabel_here, METH_VARARGS, NULL},
	 { "relabel_game_here", _wrap_relabel_game_here, METH_VARARGS, NULL},
	 { "new_translator", _wrap_new_translator, METH_VARARGS, NULL},
	 { "delete_translator", _wrap_delete_translator, METH_O, NULL},
	 { "translator_set_type", _wrap_translator_set_type, METH_VARARGS, NULL},
	 { "translator_set_pref", _wrap_translator_set_pref, METH_VARARGS, NULL},
	 { "translator_set_level", _wrap_translator_set_level, METH_VARARGS, NULL},
	 { "translator_run", _wrap_translator_run, METH_VARARGS, NULL},
	 { "translator_clear_caches", _wrap_translator_clear_caches, METH_O, NULL},
	 { "translator_swigregister", translator_swigregister, METH_O, NULL},
	 { "translator_swiginit", translator_swiginit, METH_VARARGS, NULL},
	 { "to_weak_alternating", _wrap_to_weak_alternating, METH_VARARGS, NULL},
	 { "print_hoa", _wrap_print_hoa, METH_VARARGS, NULL},
	 { "get_aliases", _wrap_get_aliases, METH_O, NULL},
	 { "set_aliases", _wrap_set_aliases, METH_VARARGS, NULL},
	 { "new_hoa_alias_formater", _wrap_new_hoa_alias_formater, METH_VARARGS, NULL},
	 { "hoa_alias_formater_encode_label", _wrap_hoa_alias_formater_encode_label, METH_VARARGS, NULL},
	 { "hoa_alias_formater_aliases", _wrap_hoa_alias_formater_aliases, METH_O, NULL},
	 { "delete_hoa_alias_formater", _wrap_delete_hoa_alias_formater, METH_O, NULL},
	 { "hoa_alias_formater_swigregister", hoa_alias_formater_swigregister, METH_O, NULL},
	 { "hoa_alias_formater_swiginit", hoa_alias_formater_swiginit, METH_VARARGS, NULL},
	 { "dtwa_sat_synthetize", _wrap_dtwa_sat_synthetize, METH_VARARGS, NULL},
	 { "dtwa_sat_minimize", _wrap_dtwa_sat_minimize, METH_VARARGS, NULL},
	 { "dtwa_sat_minimize_dichotomy", _wrap_dtwa_sat_minimize_dichotomy, METH_VARARGS, NULL},
	 { "dtwa_sat_minimize_incr", _wrap_dtwa_sat_minimize_incr, METH_VARARGS, NULL},
	 { "dtwa_sat_minimize_assume", _wrap_dtwa_sat_minimize_assume, METH_VARARGS, NULL},
	 { "sat_minimize", _wrap_sat_minimize, METH_VARARGS, NULL},
	 { "relabel_here", _wrap_relabel_here, METH_VARARGS, NULL},
	 { "partitioned_relabel_here", _wrap_partitioned_relabel_here, METH_VARARGS, NULL},
	 { "new_twa_word", _wrap_new_twa_word, METH_VARARGS, NULL},
	 { "delete_twa_word", _wrap_delete_twa_word, METH_O, NULL},
	 { "twa_word_simplify", _wrap_twa_word_simplify, METH_O, NULL},
	 { "twa_word_use_all_aps", _wrap_twa_word_use_all_aps, METH_VARARGS, NULL},
	 { "twa_word_prefix_set", _wrap_twa_word_prefix_set, METH_VARARGS, NULL},
	 { "twa_word_prefix_get", _wrap_twa_word_prefix_get, METH_O, NULL},
	 { "twa_word_cycle_set", _wrap_twa_word_cycle_set, METH_VARARGS, NULL},
	 { "twa_word_cycle_get", _wrap_twa_word_cycle_get, METH_O, NULL},
	 { "twa_word_get_dict", _wrap_twa_word_get_dict, METH_O, NULL},
	 { "twa_word_as_automaton", _wrap_twa_word_as_automaton, METH_O, NULL},
	 { "twa_word___str__", _wrap_twa_word___str__, METH_O, NULL},
	 { "twa_word_swigregister", twa_word_swigregister, METH_O, NULL},
	 { "twa_word_swiginit", twa_word_swiginit, METH_VARARGS, NULL},
	 { "make_twa_word", _wrap_make_twa_word, METH_VARARGS, NULL},
	 { "parse_word", _wrap_parse_word, METH_VARARGS, NULL},
	 { "list_bdd_iterator", _wrap_list_bdd_iterator, METH_O, NULL},
	 { "list_bdd___nonzero__", _wrap_list_bdd___nonzero__, METH_O, NULL},
	 { "list_bdd___bool__", _wrap_list_bdd___bool__, METH_O, NULL},
	 { "list_bdd___len__", _wrap_list_bdd___len__, METH_O, NULL},
	 { "list_bdd___getslice__", _wrap_list_bdd___getslice__, METH_VARARGS, NULL},
	 { "list_bdd___setslice__", _wrap_list_bdd___setslice__, METH_VARARGS, NULL},
	 { "list_bdd___delslice__", _wrap_list_bdd___delslice__, METH_VARARGS, NULL},
	 { "list_bdd___delitem__", _wrap_list_bdd___delitem__, METH_VARARGS, NULL},
	 { "list_bdd___getitem__", _wrap_list_bdd___getitem__, METH_VARARGS, NULL},
	 { "list_bdd___setitem__", _wrap_list_bdd___setitem__, METH_VARARGS, NULL},
	 { "list_bdd_pop", _wrap_list_bdd_pop, METH_O, NULL},
	 { "list_bdd_append", _wrap_list_bdd_append, METH_VARARGS, NULL},
	 { "list_bdd_empty", _wrap_list_bdd_empty, METH_O, NULL},
	 { "list_bdd_size", _wrap_list_bdd_size, METH_O, NULL},
	 { "list_bdd_swap", _wrap_list_bdd_swap, METH_VARARGS, NULL},
	 { "list_bdd_begin", _wrap_list_bdd_begin, METH_O, NULL},
	 { "list_bdd_end", _wrap_list_bdd_end, METH_O, NULL},
	 { "list_bdd_rbegin", _wrap_list_bdd_rbegin, METH_O, NULL},
	 { "list_bdd_rend", _wrap_list_bdd_rend, METH_O, NULL},
	 { "list_bdd_clear", _wrap_list_bdd_clear, METH_O, NULL},
	 { "list_bdd_get_allocator", _wrap_list_bdd_get_allocator, METH_O, NULL},
	 { "list_bdd_pop_back", _wrap_list_bdd_pop_back, METH_O, NULL},
	 { "list_bdd_erase", _wrap_list_bdd_erase, METH_VARARGS, NULL},
	 { "new_list_bdd", _wrap_new_list_bdd, METH_VARARGS, NULL},
	 { "list_bdd_push_back", _wrap_list_bdd_push_back, METH_VARARGS, NULL},
	 { "list_bdd_front", _wrap_list_bdd_front, METH_O, NULL},
	 { "list_bdd_back", _wrap_list_bdd_back, METH_O, NULL},
	 { "list_bdd_assign", _wrap_list_bdd_assign, METH_VARARGS, NULL},
	 { "list_bdd_resize", _wrap_list_bdd_resize, METH_VARARGS, NULL},
	 { "list_bdd_insert", _wrap_list_bdd_insert, METH_VARARGS, NULL},
	 { "list_bdd_pop_front", _wrap_list_bdd_pop_front, METH_O, NULL},
	 { "list_bdd_push_front", _wrap_list_bdd_push_front, METH_VARARGS, NULL},
	 { "list_bdd_reverse", _wrap_list_bdd_reverse, METH_O, NULL},
	 { "delete_list_bdd", _wrap_delete_list_bdd, METH_O, NULL},
	 { "list_bdd_swigregister", list_bdd_swigregister, METH_O, NULL},
	 { "list_bdd_swiginit", list_bdd_swiginit, METH_VARARGS, NULL},
	 { "new_isomorphism_checker", _wrap_new_isomorphism_checker, METH_O, NULL},
	 { "isomorphism_checker_is_isomorphic", _wrap_isomorphism_checker_is_isomorphic, METH_VARARGS, NULL},
	 { "isomorphism_checker_are_isomorphic", _wrap_isomorphism_checker_are_isomorphic, METH_VARARGS, NULL},
	 { "delete_isomorphism_checker", _wrap_delete_isomorphism_checker, METH_O, NULL},
	 { "isomorphism_checker_swigregister", isomorphism_checker_swigregister, METH_O, NULL},
	 { "isomorphism_checker_swiginit", isomorphism_checker_swiginit, METH_VARARGS, NULL},
	 { "to_parity_data_nb_states_created_set", _wrap_to_parity_data_nb_states_created_set, METH_VARARGS, NULL},
	 { "to_parity_data_nb_states_created_get", _wrap_to_parity_data_nb_states_created_get, METH_O, NULL},
	 { "to_parity_data_nb_edges_created_set", _wrap_to_parity_data_nb_edges_created_set, METH_VARARGS, NULL},
	 { "to_parity_data_nb_edges_created_get", _wrap_to_parity_data_nb_edges_created_get, METH_O, NULL},
	 { "to_parity_data_algorithms_used_set", _wrap_to_parity_data_algorithms_used_set, METH_VARARGS, NULL},
	 { "to_parity_data_algorithms_used_get", _wrap_to_parity_data_algorithms_used_get, METH_O, NULL},
	 { "new_to_parity_data", _wrap_new_to_parity_data, METH_NOARGS, NULL},
	 { "delete_to_parity_data", _wrap_delete_to_parity_data, METH_O, NULL},
	 { "to_parity_data_swigregister", to_parity_data_swigregister, METH_O, NULL},
	 { "to_parity_data_swiginit", to_parity_data_swiginit, METH_VARARGS, NULL},
	 { "to_parity_options_search_ex_set", _wrap_to_parity_options_search_ex_set, METH_VARARGS, NULL},
	 { "to_parity_options_search_ex_get", _wrap_to_parity_options_search_ex_get, METH_O, NULL},
	 { "to_parity_options_use_last_set", _wrap_to_parity_options_use_last_set, METH_VARARGS, NULL},
	 { "to_parity_options_use_last_get", _wrap_to_parity_options_use_last_get, METH_O, NULL},
	 { "to_parity_options_use_last_post_process_set", _wrap_to_parity_options_use_last_post_process_set, METH_VARARGS, NULL},
	 { "to_parity_options_use_last_post_process_get", _wrap_to_parity_options_use_last_post_process_get, METH_O, NULL},
	 { "to_parity_options_force_order_set", _wrap_to_parity_options_force_order_set, METH_VARARGS, NULL},
	 { "to_parity_options_force_order_get", _wrap_to_parity_options_force_order_get, METH_O, NULL},
	 { "to_parity_options_partial_degen_set", _wrap_to_parity_options_partial_degen_set, METH_VARARGS, NULL},
	 { "to_parity_options_partial_degen_get", _wrap_to_parity_options_partial_degen_get, METH_O, NULL},
	 { "to_parity_options_acc_clean_set", _wrap_to_parity_options_acc_clean_set, METH_VARARGS, NULL},
	 { "to_parity_options_acc_clean_get", _wrap_to_parity_options_acc_clean_get, METH_O, NULL},
	 { "to_parity_options_parity_equiv_set", _wrap_to_parity_options_parity_equiv_set, METH_VARARGS, NULL},
	 { "to_parity_options_parity_equiv_get", _wrap_to_parity_options_parity_equiv_get, METH_O, NULL},
	 { "to_parity_options_car_set", _wrap_to_parity_options_car_set, METH_VARARGS, NULL},
	 { "to_parity_options_car_get", _wrap_to_parity_options_car_get, METH_O, NULL},
	 { "to_parity_options_tar_set", _wrap_to_parity_options_tar_set, METH_VARARGS, NULL},
	 { "to_parity_options_tar_get", _wrap_to_parity_options_tar_get, METH_O, NULL},
	 { "to_parity_options_iar_set", _wrap_to_parity_options_iar_set, METH_VARARGS, NULL},
	 { "to_parity_options_iar_get", _wrap_to_parity_options_iar_get, METH_O, NULL},
	 { "to_parity_options_lar_dfs_set", _wrap_to_parity_options_lar_dfs_set, METH_VARARGS, NULL},
	 { "to_parity_options_lar_dfs_get", _wrap_to_parity_options_lar_dfs_get, METH_O, NULL},
	 { "to_parity_options_bscc_set", _wrap_to_parity_options_bscc_set, METH_VARARGS, NULL},
	 { "to_parity_options_bscc_get", _wrap_to_parity_options_bscc_get, METH_O, NULL},
	 { "to_parity_options_parity_prefix_set", _wrap_to_parity_options_parity_prefix_set, METH_VARARGS, NULL},
	 { "to_parity_options_parity_prefix_get", _wrap_to_parity_options_parity_prefix_get, METH_O, NULL},
	 { "to_parity_options_parity_prefix_general_set", _wrap_to_parity_options_parity_prefix_general_set, METH_VARARGS, NULL},
	 { "to_parity_options_parity_prefix_general_get", _wrap_to_parity_options_parity_prefix_general_get, METH_O, NULL},
	 { "to_parity_options_generic_emptiness_set", _wrap_to_parity_options_generic_emptiness_set, METH_VARARGS, NULL},
	 { "to_parity_options_generic_emptiness_get", _wrap_to_parity_options_generic_emptiness_get, METH_O, NULL},
	 { "to_parity_options_rabin_to_buchi_set", _wrap_to_parity_options_rabin_to_buchi_set, METH_VARARGS, NULL},
	 { "to_parity_options_rabin_to_buchi_get", _wrap_to_parity_options_rabin_to_buchi_get, METH_O, NULL},
	 { "to_parity_options_buchi_type_to_buchi_set", _wrap_to_parity_options_buchi_type_to_buchi_set, METH_VARARGS, NULL},
	 { "to_parity_options_buchi_type_to_buchi_get", _wrap_to_parity_options_buchi_type_to_buchi_get, METH_O, NULL},
	 { "to_parity_options_parity_type_to_parity_set", _wrap_to_parity_options_parity_type_to_parity_set, METH_VARARGS, NULL},
	 { "to_parity_options_parity_type_to_parity_get", _wrap_to_parity_options_parity_type_to_parity_get, METH_O, NULL},
	 { "to_parity_options_reduce_col_deg_set", _wrap_to_parity_options_reduce_col_deg_set, METH_VARARGS, NULL},
	 { "to_parity_options_reduce_col_deg_get", _wrap_to_parity_options_reduce_col_deg_get, METH_O, NULL},
	 { "to_parity_options_propagate_col_set", _wrap_to_parity_options_propagate_col_set, METH_VARARGS, NULL},
	 { "to_parity_options_propagate_col_get", _wrap_to_parity_options_propagate_col_get, METH_O, NULL},
	 { "to_parity_options_use_generalized_rabin_set", _wrap_to_parity_options_use_generalized_rabin_set, METH_VARARGS, NULL},
	 { "to_parity_options_use_generalized_rabin_get", _wrap_to_parity_options_use_generalized_rabin_get, METH_O, NULL},
	 { "to_parity_options_pretty_print_set", _wrap_to_parity_options_pretty_print_set, METH_VARARGS, NULL},
	 { "to_parity_options_pretty_print_get", _wrap_to_parity_options_pretty_print_get, METH_O, NULL},
	 { "to_parity_options_datas_set", _wrap_to_parity_options_datas_set, METH_VARARGS, NULL},
	 { "to_parity_options_datas_get", _wrap_to_parity_options_datas_get, METH_O, NULL},
	 { "new_to_parity_options", _wrap_new_to_parity_options, METH_NOARGS, NULL},
	 { "delete_to_parity_options", _wrap_delete_to_parity_options, METH_O, NULL},
	 { "to_parity_options_swigregister", to_parity_options_swigregister, METH_O, NULL},
	 { "to_parity_options_swiginit", to_parity_options_swiginit, METH_VARARGS, NULL},
	 { "to_parity", _wrap_to_parity, METH_VARARGS, NULL},
	 { "to_parity_old", _wrap_to_parity_old, METH_VARARGS, NULL},
	 { "iar", _wrap_iar, METH_VARARGS, NULL},
	 { "iar_maybe", _wrap_iar_maybe, METH_VARARGS, NULL},
	 { "parity_type_to_parity", _wrap_parity_type_to_parity, METH_O, NULL},
	 { "buchi_type_to_buchi", _wrap_buchi_type_to_buchi, METH_O, NULL},
	 { "co_buchi_type_to_co_buchi", _wrap_co_buchi_type_to_co_buchi, METH_O, NULL},
	 { "new_zielonka_tree", _wrap_new_zielonka_tree, METH_VARARGS, NULL},
	 { "zielonka_tree_num_branches", _wrap_zielonka_tree_num_branches, METH_O, NULL},
	 { "zielonka_tree_first_branch", _wrap_zielonka_tree_first_branch, METH_O, NULL},
	 { "zielonka_tree_step", _wrap_zielonka_tree_step, METH_VARARGS, NULL},
	 { "zielonka_tree_is_even", _wrap_zielonka_tree_is_even, METH_O, NULL},
	 { "zielonka_tree_has_rabin_shape", _wrap_zielonka_tree_has_rabin_shape, METH_O, NULL},
	 { "zielonka_tree_has_streett_shape", _wrap_zielonka_tree_has_streett_shape, METH_O, NULL},
	 { "zielonka_tree_has_parity_shape", _wrap_zielonka_tree_has_parity_shape, METH_O, NULL},
	 { "zielonka_tree_dot", _wrap_zielonka_tree_dot, METH_VARARGS, NULL},
	 { "zielonka_tree_nodes__set", _wrap_zielonka_tree_nodes__set, METH_VARARGS, NULL},
	 { "zielonka_tree_nodes__get", _wrap_zielonka_tree_nodes__get, METH_O, NULL},
	 { "delete_zielonka_tree", _wrap_delete_zielonka_tree, METH_O, NULL},
	 { "zielonka_tree_swigregister", zielonka_tree_swigregister, METH_O, NULL},
	 { "zielonka_tree_swiginit", zielonka_tree_swiginit, METH_VARARGS, NULL},
	 { "zielonka_tree_transform", _wrap_zielonka_tree_transform, METH_O, NULL},
	 { "new_acd", _wrap_new_acd, METH_VARARGS, NULL},
	 { "delete_acd", _wrap_delete_acd, METH_O, NULL},
	 { "acd_step", _wrap_acd_step, METH_VARARGS, NULL},
	 { "acd_state_step", _wrap_acd_state_step, METH_VARARGS, NULL},
	 { "acd_edges_of_node", _wrap_acd_edges_of_node, METH_VARARGS, NULL},
	 { "acd_node_count", _wrap_acd_node_count, METH_O, NULL},
	 { "acd_node_acceptance", _wrap_acd_node_acceptance, METH_VARARGS, NULL},
	 { "acd_node_level", _wrap_acd_node_level, METH_VARARGS, NULL},
	 { "acd_node_colors", _wrap_acd_node_colors, METH_VARARGS, NULL},
	 { "acd_is_even", _wrap_acd_is_even, METH_VARARGS, NULL},
	 { "acd_first_branch", _wrap_acd_first_branch, METH_VARARGS, NULL},
	 { "acd_scc_max_level", _wrap_acd_scc_max_level, METH_VARARGS, NULL},
	 { "acd_has_rabin_shape", _wrap_acd_has_rabin_shape, METH_O, NULL},
	 { "acd_has_streett_shape", _wrap_acd_has_streett_shape, METH_O, NULL},
	 { "acd_has_parity_shape", _wrap_acd_has_parity_shape, METH_O, NULL},
	 { "acd_get_aut", _wrap_acd_get_aut, METH_O, NULL},
	 { "acd_dot", _wrap_acd_dot, METH_VARARGS, NULL},
	 { "acd_swigregister", acd_swigregister, METH_O, NULL},
	 { "acd_swiginit", acd_swiginit, METH_VARARGS, NULL},
	 { "acd_transform", _wrap_acd_transform, METH_VARARGS, NULL},
	 { "acd_transform_sbacc", _wrap_acd_transform_sbacc, METH_VARARGS, NULL},
	 { "dtwa_complement", _wrap_dtwa_complement, METH_O, NULL},
	 { "complement_semidet", _wrap_complement_semidet, METH_VARARGS, NULL},
	 { "complement", _wrap_complement, METH_VARARGS, NULL},
	 { "delete_fair_kripke_succ_iterator", _wrap_delete_fair_kripke_succ_iterator, METH_O, NULL},
	 { "fair_kripke_succ_iterator_swigregister", fair_kripke_succ_iterator_swigregister, METH_O, NULL},
	 { "fair_kripke_state_condition", _wrap_fair_kripke_state_condition, METH_VARARGS, NULL},
	 { "fair_kripke_state_acceptance_mark", _wrap_fair_kripke_state_acceptance_mark, METH_VARARGS, NULL},
	 { "delete_fair_kripke", _wrap_delete_fair_kripke, METH_O, NULL},
	 { "fair_kripke_swigregister", fair_kripke_swigregister, METH_O, NULL},
	 { "kripke_succ_iterator_recycle", _wrap_kripke_succ_iterator_recycle, METH_VARARGS, NULL},
	 { "delete_kripke_succ_iterator", _wrap_delete_kripke_succ_iterator, METH_O, NULL},
	 { "kripke_succ_iterator_swigregister", kripke_succ_iterator_swigregister, METH_O, NULL},
	 { "delete_kripke", _wrap_delete_kripke, METH_O, NULL},
	 { "kripke_swigregister", kripke_swigregister, METH_O, NULL},
	 { "new_kripke_graph_state", _wrap_new_kripke_graph_state, METH_VARARGS, NULL},
	 { "delete_kripke_graph_state", _wrap_delete_kripke_graph_state, METH_O, NULL},
	 { "kripke_graph_state_clone", _wrap_kripke_graph_state_clone, METH_O, NULL},
	 { "kripke_graph_state_cond", _wrap_kripke_graph_state_cond, METH_VARARGS, NULL},
	 { "kripke_graph_state_swigregister", kripke_graph_state_swigregister, METH_O, NULL},
	 { "kripke_graph_state_swiginit", kripke_graph_state_swiginit, METH_VARARGS, NULL},
	 { "new_kripke_graph", _wrap_new_kripke_graph, METH_O, NULL},
	 { "delete_kripke_graph", _wrap_delete_kripke_graph, METH_O, NULL},
	 { "kripke_graph_num_states", _wrap_kripke_graph_num_states, METH_O, NULL},
	 { "kripke_graph_num_edges", _wrap_kripke_graph_num_edges, METH_O, NULL},
	 { "kripke_graph_set_init_state", _wrap_kripke_graph_set_init_state, METH_VARARGS, NULL},
	 { "kripke_graph_get_init_state_number", _wrap_kripke_graph_get_init_state_number, METH_O, NULL},
	 { "kripke_graph_get_init_state", _wrap_kripke_graph_get_init_state, METH_O, NULL},
	 { "kripke_graph_succ_iter", _wrap_kripke_graph_succ_iter, METH_VARARGS, NULL},
	 { "kripke_graph_state_number", _wrap_kripke_graph_state_number, METH_VARARGS, NULL},
	 { "kripke_graph_state_from_number", _wrap_kripke_graph_state_from_number, METH_VARARGS, NULL},
	 { "kripke_graph_format_state", _wrap_kripke_graph_format_state, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage", _wrap_kripke_graph_edge_storage, METH_VARARGS, NULL},
	 { "kripke_graph_new_state", _wrap_kripke_graph_new_state, METH_VARARGS, NULL},
	 { "kripke_graph_new_states", _wrap_kripke_graph_new_states, METH_VARARGS, NULL},
	 { "kripke_graph_new_edge", _wrap_kripke_graph_new_edge, METH_VARARGS, NULL},
	 { "kripke_graph_states", _wrap_kripke_graph_states, METH_O, NULL},
	 { "kripke_graph_edges", _wrap_kripke_graph_edges, METH_O, NULL},
	 { "kripke_graph_out", _wrap_kripke_graph_out, METH_VARARGS, NULL},
	 { "kripke_graph_swigregister", kripke_graph_swigregister, METH_O, NULL},
	 { "kripke_graph_swiginit", kripke_graph_swiginit, METH_VARARGS, NULL},
	 { "make_kripke_graph", _wrap_make_kripke_graph, METH_O, NULL},
	 { "new_kripke_graph_state_out", _wrap_new_kripke_graph_state_out, METH_VARARGS, NULL},
	 { "kripke_graph_state_out_begin", _wrap_kripke_graph_state_out_begin, METH_O, NULL},
	 { "kripke_graph_state_out_end", _wrap_kripke_graph_state_out_end, METH_O, NULL},
	 { "kripke_graph_state_out_recycle", _wrap_kripke_graph_state_out_recycle, METH_VARARGS, NULL},
	 { "kripke_graph_state_out___iter__", _wrap_kripke_graph_state_out___iter__, METH_O, NULL},
	 { "delete_kripke_graph_state_out", _wrap_delete_kripke_graph_state_out, METH_O, NULL},
	 { "kripke_graph_state_out_swigregister", kripke_graph_state_out_swigregister, METH_O, NULL},
	 { "kripke_graph_state_out_swiginit", kripke_graph_state_out_swiginit, METH_VARARGS, NULL},
	 { "new_kripke_graph_all_trans", _wrap_new_kripke_graph_all_trans, METH_O, NULL},
	 { "kripke_graph_all_trans_begin", _wrap_kripke_graph_all_trans_begin, METH_O, NULL},
	 { "kripke_graph_all_trans_end", _wrap_kripke_graph_all_trans_end, METH_O, NULL},
	 { "kripke_graph_all_trans___iter__", _wrap_kripke_graph_all_trans___iter__, METH_O, NULL},
	 { "delete_kripke_graph_all_trans", _wrap_delete_kripke_graph_all_trans, METH_O, NULL},
	 { "kripke_graph_all_trans_swigregister", kripke_graph_all_trans_swigregister, METH_O, NULL},
	 { "kripke_graph_all_trans_swiginit", kripke_graph_all_trans_swiginit, METH_VARARGS, NULL},
	 { "kripke_graph_edge_boxed_data_data", _wrap_kripke_graph_edge_boxed_data_data, METH_VARARGS, NULL},
	 { "new_kripke_graph_edge_boxed_data", _wrap_new_kripke_graph_edge_boxed_data, METH_NOARGS, NULL},
	 { "delete_kripke_graph_edge_boxed_data", _wrap_delete_kripke_graph_edge_boxed_data, METH_O, NULL},
	 { "kripke_graph_edge_boxed_data_swigregister", kripke_graph_edge_boxed_data_swigregister, METH_O, NULL},
	 { "kripke_graph_edge_boxed_data_swiginit", kripke_graph_edge_boxed_data_swiginit, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage_dst_set", _wrap_kripke_graph_edge_storage_dst_set, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage_dst_get", _wrap_kripke_graph_edge_storage_dst_get, METH_O, NULL},
	 { "kripke_graph_edge_storage_next_succ_set", _wrap_kripke_graph_edge_storage_next_succ_set, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage_next_succ_get", _wrap_kripke_graph_edge_storage_next_succ_get, METH_O, NULL},
	 { "kripke_graph_edge_storage_src_set", _wrap_kripke_graph_edge_storage_src_set, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage_src_get", _wrap_kripke_graph_edge_storage_src_get, METH_O, NULL},
	 { "new_kripke_graph_edge_storage", _wrap_new_kripke_graph_edge_storage, METH_NOARGS, NULL},
	 { "kripke_graph_edge_storage___lt__", _wrap_kripke_graph_edge_storage___lt__, METH_VARARGS, NULL},
	 { "kripke_graph_edge_storage___eq__", _wrap_kripke_graph_edge_storage___eq__, METH_VARARGS, NULL},
	 { "delete_kripke_graph_edge_storage", _wrap_delete_kripke_graph_edge_storage, METH_O, NULL},
	 { "kripke_graph_edge_storage_swigregister", kripke_graph_edge_storage_swigregister, METH_O, NULL},
	 { "kripke_graph_edge_storage_swiginit", kripke_graph_edge_storage_swiginit, METH_VARARGS, NULL},
	 { "new_kripke_graph_state_boxed_data", _wrap_new_kripke_graph_state_boxed_data, METH_NOARGS, NULL},
	 { "kripke_graph_state_boxed_data_data", _wrap_kripke_graph_state_boxed_data_data, METH_VARARGS, NULL},
	 { "delete_kripke_graph_state_boxed_data", _wrap_delete_kripke_graph_state_boxed_data, METH_O, NULL},
	 { "kripke_graph_state_boxed_data_swigregister", kripke_graph_state_boxed_data_swigregister, METH_O, NULL},
	 { "kripke_graph_state_boxed_data_swiginit", kripke_graph_state_boxed_data_swiginit, METH_VARARGS, NULL},
	 { "kripke_graph_state_storage_succ_set", _wrap_kripke_graph_state_storage_succ_set, METH_VARARGS, NULL},
	 { "kripke_graph_state_storage_succ_get", _wrap_kripke_graph_state_storage_succ_get, METH_O, NULL},
	 { "kripke_graph_state_storage_succ_tail_set", _wrap_kripke_graph_state_storage_succ_tail_set, METH_VARARGS, NULL},
	 { "kripke_graph_state_storage_succ_tail_get", _wrap_kripke_graph_state_storage_succ_tail_get, METH_O, NULL},
	 { "new_kripke_graph_state_storage", _wrap_new_kripke_graph_state_storage, METH_NOARGS, NULL},
	 { "delete_kripke_graph_state_storage", _wrap_delete_kripke_graph_state_storage, METH_O, NULL},
	 { "kripke_graph_state_storage_swigregister", kripke_graph_state_storage_swigregister, METH_O, NULL},
	 { "kripke_graph_state_storage_swiginit", kripke_graph_state_storage_swiginit, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_iterator", _wrap_kripke_graph_state_vector_iterator, METH_O, NULL},
	 { "kripke_graph_state_vector___nonzero__", _wrap_kripke_graph_state_vector___nonzero__, METH_O, NULL},
	 { "kripke_graph_state_vector___bool__", _wrap_kripke_graph_state_vector___bool__, METH_O, NULL},
	 { "kripke_graph_state_vector___len__", _wrap_kripke_graph_state_vector___len__, METH_O, NULL},
	 { "kripke_graph_state_vector___getslice__", _wrap_kripke_graph_state_vector___getslice__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector___setslice__", _wrap_kripke_graph_state_vector___setslice__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector___delslice__", _wrap_kripke_graph_state_vector___delslice__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector___delitem__", _wrap_kripke_graph_state_vector___delitem__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector___getitem__", _wrap_kripke_graph_state_vector___getitem__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector___setitem__", _wrap_kripke_graph_state_vector___setitem__, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_pop", _wrap_kripke_graph_state_vector_pop, METH_O, NULL},
	 { "kripke_graph_state_vector_append", _wrap_kripke_graph_state_vector_append, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_empty", _wrap_kripke_graph_state_vector_empty, METH_O, NULL},
	 { "kripke_graph_state_vector_size", _wrap_kripke_graph_state_vector_size, METH_O, NULL},
	 { "kripke_graph_state_vector_swap", _wrap_kripke_graph_state_vector_swap, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_begin", _wrap_kripke_graph_state_vector_begin, METH_O, NULL},
	 { "kripke_graph_state_vector_end", _wrap_kripke_graph_state_vector_end, METH_O, NULL},
	 { "kripke_graph_state_vector_rbegin", _wrap_kripke_graph_state_vector_rbegin, METH_O, NULL},
	 { "kripke_graph_state_vector_rend", _wrap_kripke_graph_state_vector_rend, METH_O, NULL},
	 { "kripke_graph_state_vector_clear", _wrap_kripke_graph_state_vector_clear, METH_O, NULL},
	 { "kripke_graph_state_vector_get_allocator", _wrap_kripke_graph_state_vector_get_allocator, METH_O, NULL},
	 { "kripke_graph_state_vector_pop_back", _wrap_kripke_graph_state_vector_pop_back, METH_O, NULL},
	 { "kripke_graph_state_vector_erase", _wrap_kripke_graph_state_vector_erase, METH_VARARGS, NULL},
	 { "new_kripke_graph_state_vector", _wrap_new_kripke_graph_state_vector, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_push_back", _wrap_kripke_graph_state_vector_push_back, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_front", _wrap_kripke_graph_state_vector_front, METH_O, NULL},
	 { "kripke_graph_state_vector_back", _wrap_kripke_graph_state_vector_back, METH_O, NULL},
	 { "kripke_graph_state_vector_assign", _wrap_kripke_graph_state_vector_assign, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_resize", _wrap_kripke_graph_state_vector_resize, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_insert", _wrap_kripke_graph_state_vector_insert, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_reserve", _wrap_kripke_graph_state_vector_reserve, METH_VARARGS, NULL},
	 { "kripke_graph_state_vector_capacity", _wrap_kripke_graph_state_vector_capacity, METH_O, NULL},
	 { "delete_kripke_graph_state_vector", _wrap_delete_kripke_graph_state_vector, METH_O, NULL},
	 { "kripke_graph_state_vector_swigregister", kripke_graph_state_vector_swigregister, METH_O, NULL},
	 { "kripke_graph_state_vector_swiginit", kripke_graph_state_vector_swiginit, METH_VARARGS, NULL},
	 { "parse_aut_error_list___nonzero__", _wrap_parse_aut_error_list___nonzero__, METH_O, NULL},
	 { "parse_aut_error_list___bool__", _wrap_parse_aut_error_list___bool__, METH_O, NULL},
	 { "new_parse_aut_error_list", _wrap_new_parse_aut_error_list, METH_NOARGS, NULL},
	 { "delete_parse_aut_error_list", _wrap_delete_parse_aut_error_list, METH_O, NULL},
	 { "parse_aut_error_list_swigregister", parse_aut_error_list_swigregister, METH_O, NULL},
	 { "parse_aut_error_list_swiginit", parse_aut_error_list_swiginit, METH_VARARGS, NULL},
	 { "parsed_aut_aut_set", _wrap_parsed_aut_aut_set, METH_VARARGS, NULL},
	 { "parsed_aut_aut_get", _wrap_parsed_aut_aut_get, METH_O, NULL},
	 { "parsed_aut_ks_set", _wrap_parsed_aut_ks_set, METH_VARARGS, NULL},
	 { "parsed_aut_ks_get", _wrap_parsed_aut_ks_get, METH_O, NULL},
	 { "parsed_aut_aborted_set", _wrap_parsed_aut_aborted_set, METH_VARARGS, NULL},
	 { "parsed_aut_aborted_get", _wrap_parsed_aut_aborted_get, METH_O, NULL},
	 { "parsed_aut_loc_set", _wrap_parsed_aut_loc_set, METH_VARARGS, NULL},
	 { "parsed_aut_loc_get", _wrap_parsed_aut_loc_get, METH_O, NULL},
	 { "parsed_aut_type_set", _wrap_parsed_aut_type_set, METH_VARARGS, NULL},
	 { "parsed_aut_type_get", _wrap_parsed_aut_type_get, METH_O, NULL},
	 { "parsed_aut_filename_set", _wrap_parsed_aut_filename_set, METH_VARARGS, NULL},
	 { "parsed_aut_filename_get", _wrap_parsed_aut_filename_get, METH_O, NULL},
	 { "parsed_aut_errors_set", _wrap_parsed_aut_errors_set, METH_VARARGS, NULL},
	 { "parsed_aut_errors_get", _wrap_parsed_aut_errors_get, METH_O, NULL},
	 { "new_parsed_aut", _wrap_new_parsed_aut, METH_O, NULL},
	 { "parsed_aut_format_errors", _wrap_parsed_aut_format_errors, METH_VARARGS, NULL},
	 { "delete_parsed_aut", _wrap_delete_parsed_aut, METH_O, NULL},
	 { "parsed_aut_swigregister", parsed_aut_swigregister, METH_O, NULL},
	 { "parsed_aut_swiginit", parsed_aut_swiginit, METH_VARARGS, NULL},
	 { "automaton_parser_options_ignore_abort_set", _wrap_automaton_parser_options_ignore_abort_set, METH_VARARGS, NULL},
	 { "automaton_parser_options_ignore_abort_get", _wrap_automaton_parser_options_ignore_abort_get, METH_O, NULL},
	 { "automaton_parser_options_debug_set", _wrap_automaton_parser_options_debug_set, METH_VARARGS, NULL},
	 { "automaton_parser_options_debug_get", _wrap_automaton_parser_options_debug_get, METH_O, NULL},
	 { "automaton_parser_options_trust_hoa_set", _wrap_automaton_parser_options_trust_hoa_set, METH_VARARGS, NULL},
	 { "automaton_parser_options_trust_hoa_get", _wrap_automaton_parser_options_trust_hoa_get, METH_O, NULL},
	 { "automaton_parser_options_raise_errors_set", _wrap_automaton_parser_options_raise_errors_set, METH_VARARGS, NULL},
	 { "automaton_parser_options_raise_errors_get", _wrap_automaton_parser_options_raise_errors_get, METH_O, NULL},
	 { "automaton_parser_options_want_kripke_set", _wrap_automaton_parser_options_want_kripke_set, METH_VARARGS, NULL},
	 { "automaton_parser_options_want_kripke_get", _wrap_automaton_parser_options_want_kripke_get, METH_O, NULL},
	 { "new_automaton_parser_options", _wrap_new_automaton_parser_options, METH_NOARGS, NULL},
	 { "delete_automaton_parser_options", _wrap_delete_automaton_parser_options, METH_O, NULL},
	 { "automaton_parser_options_swigregister", automaton_parser_options_swigregister, METH_O, NULL},
	 { "automaton_parser_options_swiginit", automaton_parser_options_swiginit, METH_VARARGS, NULL},
	 { "new_automaton_stream_parser", _wrap_new_automaton_stream_parser, METH_VARARGS, NULL},
	 { "delete_automaton_stream_parser", _wrap_delete_automaton_stream_parser, METH_O, NULL},
	 { "automaton_stream_parser_parse", _wrap_automaton_stream_parser_parse, METH_VARARGS, NULL},
	 { "automaton_stream_parser_swigregister", automaton_stream_parser_swigregister, METH_O, NULL},
	 { "automaton_stream_parser_swiginit", automaton_stream_parser_swiginit, METH_VARARGS, NULL},
	 { "parse_aut", _wrap_parse_aut, METH_VARARGS, NULL},
	 { "delete_ta", _wrap_delete_ta, METH_O, NULL},
	 { "ta_get_initial_states_set", _wrap_ta_get_initial_states_set, METH_O, NULL},
	 { "ta_get_artificial_initial_state", _wrap_ta_get_artificial_initial_state, METH_O, NULL},
	 { "ta_succ_iter", _wrap_ta_succ_iter, METH_VARARGS, NULL},
	 { "ta_get_dict", _wrap_ta_get_dict, METH_O, NULL},
	 { "ta_format_state", _wrap_ta_format_state, METH_VARARGS, NULL},
	 { "ta_is_accepting_state", _wrap_ta_is_accepting_state, METH_VARARGS, NULL},
	 { "ta_is_livelock_accepting_state", _wrap_ta_is_livelock_accepting_state, METH_VARARGS, NULL},
	 { "ta_is_initial_state", _wrap_ta_is_initial_state, METH_VARARGS, NULL},
	 { "ta_get_state_condition", _wrap_ta_get_state_condition, METH_VARARGS, NULL},
	 { "ta_free_state", _wrap_ta_free_state, METH_VARARGS, NULL},
	 { "ta_acc", _wrap_ta_acc, METH_VARARGS, NULL},
	 { "ta_swigregister", ta_swigregister, METH_O, NULL},
	 { "delete_ta_succ_iterator", _wrap_delete_ta_succ_iterator, METH_O, NULL},
	 { "ta_succ_iterator_swigregister", ta_succ_iterator_swigregister, METH_O, NULL},
	 { "delete_tgta", _wrap_delete_tgta, METH_O, NULL},
	 { "tgta_succ_iter_by_changeset", _wrap_tgta_succ_iter_by_changeset, METH_VARARGS, NULL},
	 { "tgta_swigregister", tgta_swigregister, METH_O, NULL},
	 { "new_ta_explicit", _wrap_new_ta_explicit, METH_VARARGS, NULL},
	 { "ta_explicit_get_tgba", _wrap_ta_explicit_get_tgba, METH_O, NULL},
	 { "ta_explicit_add_state", _wrap_ta_explicit_add_state, METH_VARARGS, NULL},
	 { "ta_explicit_add_to_initial_states_set", _wrap_ta_explicit_add_to_initial_states_set, METH_VARARGS, NULL},
	 { "ta_explicit_create_transition", _wrap_ta_explicit_create_transition, METH_VARARGS, NULL},
	 { "ta_explicit_delete_stuttering_transitions", _wrap_ta_explicit_delete_stuttering_transitions, METH_O, NULL},
	 { "delete_ta_explicit", _wrap_delete_ta_explicit, METH_O, NULL},
	 { "ta_explicit_succ_iter", _wrap_ta_explicit_succ_iter, METH_VARARGS, NULL},
	 { "ta_explicit_get_dict", _wrap_ta_explicit_get_dict, METH_O, NULL},
	 { "ta_explicit_get_artificial_initial_state", _wrap_ta_explicit_get_artificial_initial_state, METH_O, NULL},
	 { "ta_explicit_set_artificial_initial_state", _wrap_ta_explicit_set_artificial_initial_state, METH_VARARGS, NULL},
	 { "ta_explicit_delete_stuttering_and_hole_successors", _wrap_ta_explicit_delete_stuttering_and_hole_successors, METH_VARARGS, NULL},
	 { "ta_explicit_get_states_set", _wrap_ta_explicit_get_states_set, METH_O, NULL},
	 { "ta_explicit_swigregister", ta_explicit_swigregister, METH_O, NULL},
	 { "ta_explicit_swiginit", ta_explicit_swiginit, METH_VARARGS, NULL},
	 { "delete_state_ta_explicit", _wrap_delete_state_ta_explicit, METH_O, NULL},
	 { "state_ta_explicit_swigregister", state_ta_explicit_swigregister, METH_O, NULL},
	 { "new_ta_explicit_succ_iterator", _wrap_new_ta_explicit_succ_iterator, METH_VARARGS, NULL},
	 { "delete_ta_explicit_succ_iterator", _wrap_delete_ta_explicit_succ_iterator, METH_O, NULL},
	 { "ta_explicit_succ_iterator_swigregister", ta_explicit_succ_iterator_swigregister, METH_O, NULL},
	 { "ta_explicit_succ_iterator_swiginit", ta_explicit_succ_iterator_swiginit, METH_VARARGS, NULL},
	 { "make_ta_explicit", _wrap_make_ta_explicit, METH_VARARGS, NULL},
	 { "new_tgta_explicit", _wrap_new_tgta_explicit, METH_VARARGS, NULL},
	 { "tgta_explicit_get_init_state", _wrap_tgta_explicit_get_init_state, METH_O, NULL},
	 { "tgta_explicit_get_ta", _wrap_tgta_explicit_get_ta, METH_VARARGS, NULL},
	 { "delete_tgta_explicit", _wrap_delete_tgta_explicit, METH_O, NULL},
	 { "tgta_explicit_swigregister", tgta_explicit_swigregister, METH_O, NULL},
	 { "tgta_explicit_swiginit", tgta_explicit_swiginit, METH_VARARGS, NULL},
	 { "make_tgta_explicit", _wrap_make_tgta_explicit, METH_VARARGS, NULL},
	 { "tgba_to_ta", _wrap_tgba_to_ta, METH_VARARGS, NULL},
	 { "tgba_to_tgta", _wrap_tgba_to_tgta, METH_VARARGS, NULL},
	 { "print_dot", _wrap_print_dot, METH_VARARGS, NULL},
	 { "ta_statistics_edges_set", _wrap_ta_statistics_edges_set, METH_VARARGS, NULL},
	 { "ta_statistics_edges_get", _wrap_ta_statistics_edges_get, METH_O, NULL},
	 { "ta_statistics_states_set", _wrap_ta_statistics_states_set, METH_VARARGS, NULL},
	 { "ta_statistics_states_get", _wrap_ta_statistics_states_get, METH_O, NULL},
	 { "ta_statistics_acceptance_states_set", _wrap_ta_statistics_acceptance_states_set, METH_VARARGS, NULL},
	 { "ta_statistics_acceptance_states_get", _wrap_ta_statistics_acceptance_states_get, METH_O, NULL},
	 { "ta_statistics_dump", _wrap_ta_statistics_dump, METH_VARARGS, NULL},
	 { "new_ta_statistics", _wrap_new_ta_statistics, METH_NOARGS, NULL},
	 { "delete_ta_statistics", _wrap_delete_ta_statistics, METH_O, NULL},
	 { "ta_statistics_swigregister", ta_statistics_swigregister, METH_O, NULL},
	 { "ta_statistics_swiginit", ta_statistics_swiginit, METH_VARARGS, NULL},
	 { "stats_reachable", _wrap_stats_reachable, METH_VARARGS, NULL},
	 { "minimize_ta", _wrap_minimize_ta, METH_O, NULL},
	 { "minimize_tgta", _wrap_minimize_tgta, METH_O, NULL},
	 { "delete_ostream", _wrap_delete_ostream, METH_O, NULL},
	 { "ostream_swigregister", ostream_swigregister, METH_O, NULL},
	 { "new_ofstream", _wrap_new_ofstream, METH_O, NULL},
	 { "delete_ofstream", _wrap_delete_ofstream, METH_O, NULL},
	 { "ofstream_swigregister", ofstream_swigregister, METH_O, NULL},
	 { "ofstream_swiginit", ofstream_swiginit, METH_VARARGS, NULL},
	 { "new_ostringstream", _wrap_new_ostringstream, METH_NOARGS, NULL},
	 { "ostringstream_str", _wrap_ostringstream_str, METH_O, NULL},
	 { "delete_ostringstream", _wrap_delete_ostringstream, METH_O, NULL},
	 { "ostringstream_swigregister", ostringstream_swigregister, METH_O, NULL},
	 { "ostringstream_swiginit", ostringstream_swiginit, METH_VARARGS, NULL},
	 { "fnode_instances_check", _wrap_fnode_instances_check, METH_NOARGS, NULL},
	 { "ensure_digraph", _wrap_ensure_digraph, METH_O, NULL},
	 { "get_cout", _wrap_get_cout, METH_NOARGS, NULL},
	 { "nl_cout", _wrap_nl_cout, METH_NOARGS, NULL},
	 { "get_cerr", _wrap_get_cerr, METH_NOARGS, NULL},
	 { "nl_cerr", _wrap_nl_cerr, METH_NOARGS, NULL},
	 { "print_on", _wrap_print_on, METH_VARARGS, NULL},
	 { "unblock_signal", _wrap_unblock_signal, METH_O, NULL},
	 { "states_and", _wrap_states_and, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_spot__declarative_environmentTo_p_spot__environment(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::environment *)  ((spot::declarative_environment *) x));
}
static void *_p_spot__default_environmentTo_p_spot__environment(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::environment *)  ((spot::default_environment *) x));
}
static void *_p_spot__kripkeTo_p_spot__fair_kripke(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::fair_kripke *)  ((spot::kripke *) x));
}
static void *_p_spot__kripke_graphTo_p_spot__fair_kripke(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::fair_kripke *) (spot::kripke *) ((spot::kripke_graph *) x));
}
static void *_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_tTo_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::internal::boxed_label< spot::kripke_graph_state,false > *)  ((spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *) x));
}
static void *_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_tTo_p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::internal::boxed_label< spot::twa_graph_edge_data,false > *)  ((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) x));
}
static void *_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_tTo_p_spot__internal__boxed_labelT_void_true_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::internal::boxed_label< void,true > *)  ((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) x));
}
static void *_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_tTo_p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::internal::edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *)  ((spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *) x));
}
static void *_p_spot__kripke_graphTo_p_spot__kripke(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::kripke *)  ((spot::kripke_graph *) x));
}
static void *_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_tTo_p_spot__kripke_graph_state(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::kripke_graph_state *)  ((spot::internal::boxed_label< spot::kripke_graph_state,false > *) x));
}
static void *_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_tTo_p_spot__kripke_graph_state(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::kripke_graph_state *) (spot::internal::boxed_label< spot::kripke_graph_state,false > *) ((spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *) x));
}
static void *_p_spot__translatorTo_p_spot__postprocessor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::postprocessor *)  ((spot::translator *) x));
}
static void *_p_spot__random_booleanTo_p_spot__random_formula(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::random_formula *)  ((spot::random_boolean *) x));
}
static void *_p_spot__random_ltlTo_p_spot__random_formula(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::random_formula *)  ((spot::random_ltl *) x));
}
static void *_p_spot__random_pslTo_p_spot__random_formula(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::random_formula *) (spot::random_ltl *) ((spot::random_psl *) x));
}
static void *_p_spot__random_sereTo_p_spot__random_formula(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::random_formula *)  ((spot::random_sere *) x));
}
static void *_p_spot__random_pslTo_p_spot__random_ltl(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::random_ltl *)  ((spot::random_psl *) x));
}
static void *_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_tTo_p_spot__state(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::state *) (spot::kripke_graph_state *) ((spot::internal::boxed_label< spot::kripke_graph_state,false > *) x));
}
static void *_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_tTo_p_spot__state(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::state *) (spot::kripke_graph_state *)(spot::internal::boxed_label< spot::kripke_graph_state,false > *) ((spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *) x));
}
static void *_p_spot__kripke_graph_stateTo_p_spot__state(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::state *)  ((spot::kripke_graph_state *) x));
}
static void *_p_spot__set_stateTo_p_spot__state(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::state *)  ((spot::set_state *) x));
}
static void *_p_spot__state_productTo_p_spot__state(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::state *)  ((spot::state_product *) x));
}
static void *_p_spot__state_ta_explicitTo_p_spot__state(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::state *)  ((spot::state_ta_explicit *) x));
}
static void *_p_spot__twa_graph_stateTo_p_spot__state(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::state *)  ((spot::twa_graph_state *) x));
}
static void *_p_spot__univ_remover_stateTo_p_spot__state(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::state *)  ((spot::univ_remover_state *) x));
}
static void *_p_spot__ta_explicitTo_p_spot__ta(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::ta *)  ((spot::ta_explicit *) x));
}
static void *_p_spot__ta_explicit_succ_iteratorTo_p_spot__ta_succ_iterator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::ta_succ_iterator *)  ((spot::ta_explicit_succ_iterator *) x));
}
static void *_p_spot__taa_tgba_formulaTo_p_spot__taa_tgba(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::taa_tgba *)  ((spot::taa_tgba_formula *) x));
}
static void *_p_spot__taa_tgba_stringTo_p_spot__taa_tgba(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::taa_tgba *)  ((spot::taa_tgba_string *) x));
}
static void *_p_spot__tgta_explicitTo_p_spot__tgta(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::tgta *)  ((spot::tgta_explicit *) x));
}
static void *_p_spot__fair_kripkeTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *)  ((spot::fair_kripke *) x));
}
static void *_p_spot__kripkeTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *) (spot::fair_kripke *) ((spot::kripke *) x));
}
static void *_p_spot__kripke_graphTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *) (spot::fair_kripke *)(spot::kripke *) ((spot::kripke_graph *) x));
}
static void *_p_spot__taa_tgbaTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *)  ((spot::taa_tgba *) x));
}
static void *_p_spot__taa_tgba_formulaTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *) (spot::taa_tgba *) ((spot::taa_tgba_formula *) x));
}
static void *_p_spot__taa_tgba_stringTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *) (spot::taa_tgba *) ((spot::taa_tgba_string *) x));
}
static void *_p_spot__tgtaTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *)  ((spot::tgta *) x));
}
static void *_p_spot__tgta_explicitTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *) (spot::tgta *) ((spot::tgta_explicit *) x));
}
static void *_p_spot__twa_graphTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *)  ((spot::twa_graph *) x));
}
static void *_p_spot__twa_productTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *)  ((spot::twa_product *) x));
}
static void *_p_spot__twa_product_initTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *) (spot::twa_product *) ((spot::twa_product_init *) x));
}
static void *_p_spot__twa_univ_removerTo_p_spot__twa(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa *)  ((spot::twa_univ_remover *) x));
}
static void *_p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_tTo_p_spot__twa_graph_edge_data(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa_graph_edge_data *)  ((spot::internal::boxed_label< spot::twa_graph_edge_data,false > *) x));
}
static void *_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_tTo_p_spot__twa_graph_edge_data(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa_graph_edge_data *) (spot::internal::boxed_label< spot::twa_graph_edge_data,false > *) ((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *) x));
}
static void *_p_spot__twa_product_initTo_p_spot__twa_product(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa_product *)  ((spot::twa_product_init *) x));
}
static void *_p_spot__twa_sub_statisticsTo_p_spot__twa_statistics(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa_statistics *)  ((spot::twa_sub_statistics *) x));
}
static void *_p_spot__fair_kripke_succ_iteratorTo_p_spot__twa_succ_iterator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa_succ_iterator *)  ((spot::fair_kripke_succ_iterator *) x));
}
static void *_p_spot__kripke_succ_iteratorTo_p_spot__twa_succ_iterator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa_succ_iterator *)  ((spot::kripke_succ_iterator *) x));
}
static void *_p_spot__ta_explicit_succ_iteratorTo_p_spot__twa_succ_iterator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa_succ_iterator *) (spot::ta_succ_iterator *) ((spot::ta_explicit_succ_iterator *) x));
}
static void *_p_spot__ta_succ_iteratorTo_p_spot__twa_succ_iterator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa_succ_iterator *)  ((spot::ta_succ_iterator *) x));
}
static void *_p_spot__taa_succ_iteratorTo_p_spot__twa_succ_iterator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((spot::twa_succ_iterator *)  ((spot::taa_succ_iterator *) x));
}
static void *_p_std__ofstreamTo_p_std__ostream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ostream *)  ((std::ofstream *) x));
}
static void *_p_std__ostringstreamTo_p_std__ostream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::ostream *)  ((std::ostringstream *) x));
}
static void *_p_spot__parse_errorTo_p_std__runtime_error(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::runtime_error *)  ((spot::parse_error *) x));
}
static void *_p_std__shared_ptrT_spot__kripke_tTo_p_std__shared_ptrT_spot__fair_kripke_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::fair_kripke >(*(std::shared_ptr< spot::kripke > *)x);
}
static void *_p_std__shared_ptrT_spot__kripke_graph_tTo_p_std__shared_ptrT_spot__fair_kripke_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::fair_kripke >(*(std::shared_ptr< spot::kripke_graph > *)x);
}
static void *_p_std__shared_ptrT_spot__kripke_graph_tTo_p_std__shared_ptrT_spot__kripke_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::kripke >(*(std::shared_ptr< spot::kripke_graph > *)x);
}
static void *_p_std__shared_ptrT_spot__ta_explicit_tTo_p_std__shared_ptrT_spot__ta_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::ta >(*(std::shared_ptr< spot::ta_explicit > *)x);
}
static void *_p_std__shared_ptrT_spot__taa_tgba_formula_tTo_p_std__shared_ptrT_spot__taa_tgba_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::taa_tgba >(*(std::shared_ptr< spot::taa_tgba_formula > *)x);
}
static void *_p_std__shared_ptrT_spot__taa_tgba_string_tTo_p_std__shared_ptrT_spot__taa_tgba_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::taa_tgba >(*(std::shared_ptr< spot::taa_tgba_string > *)x);
}
static void *_p_std__shared_ptrT_spot__tgta_explicit_tTo_p_std__shared_ptrT_spot__tgta_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::tgta >(*(std::shared_ptr< spot::tgta_explicit > *)x);
}
static void *_p_std__shared_ptrT_spot__fair_kripke_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::fair_kripke > *)x);
}
static void *_p_std__shared_ptrT_spot__kripke_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::kripke > *)x);
}
static void *_p_std__shared_ptrT_spot__kripke_graph_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::kripke_graph > *)x);
}
static void *_p_std__shared_ptrT_spot__taa_tgba_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::taa_tgba > *)x);
}
static void *_p_std__shared_ptrT_spot__taa_tgba_formula_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::taa_tgba_formula > *)x);
}
static void *_p_std__shared_ptrT_spot__taa_tgba_string_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::taa_tgba_string > *)x);
}
static void *_p_std__shared_ptrT_spot__tgta_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::tgta > *)x);
}
static void *_p_std__shared_ptrT_spot__tgta_explicit_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::tgta_explicit > *)x);
}
static void *_p_std__shared_ptrT_spot__twa_graph_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::twa_graph > *)x);
}
static void *_p_std__shared_ptrT_spot__twa_product_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::twa_product > *)x);
}
static void *_p_std__shared_ptrT_spot__twa_product_init_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::twa_product_init > *)x);
}
static void *_p_std__shared_ptrT_spot__twa_univ_remover_tTo_p_std__shared_ptrT_spot__twa_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa >(*(std::shared_ptr< spot::twa_univ_remover > *)x);
}
static void *_p_std__shared_ptrT_spot__twa_product_init_tTo_p_std__shared_ptrT_spot__twa_product_t(void *x, int *newmemory) {
    *newmemory = SWIG_CAST_NEW_MEMORY;
    return (void *) new std::shared_ptr< spot::twa_product >(*(std::shared_ptr< spot::twa_product_init > *)x);
}
static void *_p_spot__internal__boxed_labelT_void_true_tTo_p_std__tupleT_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::tuple< > *)  ((spot::internal::boxed_label< void,true > *) x));
}
static void *_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_tTo_p_std__tupleT_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::tuple< > *) (spot::internal::boxed_label< void,true > *) ((spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *) x));
}
static swig_type_info _swigt__p_aliases_t = {"_p_aliases_t", "aliases_t *", 0, 0, (void*)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_bdd = {"_p_bdd", "std::list< bdd >::value_type *|std::vector< bdd >::value_type *|bdd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bdd_info_map = {"_p_bdd_info_map", "bdd_info_map *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bitvect = {"_p_bitvect", "bitvect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 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_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_states_set_t = {"_p_const_states_set_t", "const_states_set_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_data_t = {"_p_data_t", "data_t *", 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_dv_t = {"_p_dv_t", "dv_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ec_statistics = {"_p_ec_statistics", "ec_statistics *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_edge = {"_p_edge", "edge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_edge_filter = {"_p_edge_filter", "edge_filter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_edge_filter_choice = {"_p_edge_filter_choice", "edge_filter_choice *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_edge_storage_t = {"_p_edge_storage_t", "edge_storage_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice = {"_p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice", "spot::edge_filter|spot::scc_info::edge_filter|enum spot::edge_filter_choice (*)(spot::twa_graph::edge_storage_t const &,unsigned int,void *)", 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_fixed_size_poolT_pool_type__Safe_t = {"_p_fixed_size_poolT_pool_type__Safe_t", "fixed_size_pool< pool_type::Safe > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_fnode = {"_p_fnode", "fnode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_fv_map = {"_p_fv_map", "fv_map *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_graph_t = {"_p_graph_t", "graph_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int32_t *|int_fast16_t *|int_fast32_t *|int_least32_t *|intptr_t *|int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iter_t = {"_p_iter_t", "iter_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iterator_category = {"_p_iterator_category", "iterator_category *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_key_type = {"_p_key_type", "key_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64_t *|int_fast64_t *|int_least64_t *|intmax_t *|long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_mapped_type = {"_p_mapped_type", "mapped_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_output_aborter = {"_p_output_aborter", "output_aborter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_output_pref = {"_p_output_pref", "output_pref *", 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_f_r_q_const__std__vector__unsigned_int_std__allocator__unsigned_int_____p_void__void = {"_p_p_f_r_q_const__std__vector__unsigned_int_std__allocator__unsigned_int_____p_void__void", "spot::twa_graph::shift_action *|void (**)(std::vector< unsigned int,std::allocator< unsigned int > > const &,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_power_state = {"_p_power_state", "power_state *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_prop_map = {"_p_prop_map", "prop_map *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ref_set = {"_p_ref_set", "ref_set *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_repr_t = {"_p_repr_t", "repr_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_rs_pairs = {"_p_rs_pairs", "rs_pairs *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_safe_point = {"_p_safe_point", "safe_point *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_safe_stash = {"_p_safe_stash", "safe_stash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_scc_node = {"_p_scc_node", "scc_node *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_scc_succs = {"_p_scc_succs", "scc_succs *", 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_seq_t = {"_p_seq_t", "seq_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "int16_t *|int_least16_t *|short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "int8_t *|int_fast8_t *|int_least8_t *|signed char *", 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_spot__acc_cond = {"_p_spot__acc_cond", "std::vector< spot::acc_cond >::value_type *|spot::acc_cond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__acc_cond__acc_code = {"_p_spot__acc_cond__acc_code", "std::vector< spot::acc_cond::acc_code >::value_type *|spot::acc_cond::acc_code *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__acc_cond__acc_word = {"_p_spot__acc_cond__acc_word", "spot::acc_cond::acc_word *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__acc_cond__mark_t = {"_p_spot__acc_cond__mark_t", "spot::acc_cond::mark_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__acc_cond__rs_pair = {"_p_spot__acc_cond__rs_pair", "std::vector< spot::acc_cond::rs_pair >::value_type *|spot::acc_cond::rs_pair *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__acd = {"_p_spot__acd", "spot::acd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__aig = {"_p_spot__aig", "spot::aig *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__automaton_parser_options = {"_p_spot__automaton_parser_options", "spot::automaton_parser_options *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__automaton_stream_parser = {"_p_spot__automaton_stream_parser", "spot::automaton_stream_parser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__bdd_dict = {"_p_spot__bdd_dict", "spot::bdd_dict *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__declarative_environment = {"_p_spot__declarative_environment", "spot::declarative_environment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__default_environment = {"_p_spot__default_environment", "spot::default_environment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__digraphT_spot__kripke_graph_state_void_t = {"_p_spot__digraphT_spot__kripke_graph_state_void_t", "spot::digraph< spot::kripke_graph_state,void > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__digraphT_spot__kripke_graph_state_void_t__edge = {"_p_spot__digraphT_spot__kripke_graph_state_void_t__edge", "spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > >::edge *|spot::digraph< spot::kripke_graph_state,void >::edge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t = {"_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t", "spot::twa_graph::graph_t *|spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge = {"_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge", "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge *|spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::edge *|spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data >::edge *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_storage_t = {"_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_storage_t", "spot::twa_graph::graph_t::edge_storage_t *|spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data >::edge_storage_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__state_storage_t = {"_p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__state_storage_t", "spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::state_storage_t *|spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data >::state_storage_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__emptiness_check = {"_p_spot__emptiness_check", "spot::emptiness_check *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__emptiness_check_instantiator = {"_p_spot__emptiness_check_instantiator", "spot::emptiness_check_instantiator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__emptiness_check_result = {"_p_spot__emptiness_check_result", "spot::emptiness_check_result *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__environment = {"_p_spot__environment", "spot::environment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__fair_kripke = {"_p_spot__fair_kripke", "spot::fair_kripke *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__fair_kripke_succ_iterator = {"_p_spot__fair_kripke_succ_iterator", "spot::fair_kripke_succ_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__formula = {"_p_spot__formula", "std::map< spot::formula,spot::formula >::key_type *|std::map< spot::formula,spot::formula >::mapped_type *|std::set< spot::formula >::key_type *|std::set< spot::formula >::value_type *|std::vector< spot::formula >::value_type *|spot::formula *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__game_relabeling_map = {"_p_spot__game_relabeling_map", "spot::game_relabeling_map *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__hoa_alias_formater = {"_p_spot__hoa_alias_formater", "spot::hoa_alias_formater *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t = {"_p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t", "spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > >::iter_t *|spot::internal::all_edge_iterator< spot::digraph< spot::kripke_graph_state,void > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t = {"_p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t", "spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::iter_t *|spot::internal::all_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t = {"_p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t", "spot::internal::all_trans< spot::kripke_graph::graph_t > *|spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t = {"_p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t", "spot::internal::all_trans< spot::twa_graph::graph_t > *|spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t = {"_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t", "spot::internal::boxed_label< spot::kripke_graph_state,false > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t = {"_p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t", "spot::internal::boxed_label< spot::twa_graph_edge_data,false > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__boxed_labelT_void_true_t = {"_p_spot__internal__boxed_labelT_void_true_t", "spot::internal::boxed_label< void,true > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__const_universal_dests = {"_p_spot__internal__const_universal_dests", "spot::internal::const_universal_dests *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t = {"_p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t", "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::value_type *|spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t = {"_p_spot__internal__edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t", "spot::internal::edge_iterator< spot::digraph< spot::kripke_graph_state,void > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t = {"_p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t", "spot::internal::edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t = {"_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t", "spot::twa_graph::edge_storage_t *|spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< spot::twa_graph_edge_data,false > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t = {"_p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t", "spot::kripke_graph::edge_storage_t *|spot::internal::edge_storage< unsigned int,unsigned int,unsigned int,spot::internal::boxed_label< void,true > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__keep_all = {"_p_spot__internal__keep_all", "spot::internal::keep_all *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__keep_inner_scc = {"_p_spot__internal__keep_inner_scc", "spot::internal::keep_inner_scc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t = {"_p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t", "spot::internal::killer_edge_iterator< spot::twa_graph::graph_t > *|spot::internal::killer_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__mark_container = {"_p_spot__internal__mark_container", "spot::internal::mark_container *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__mark_iterator = {"_p_spot__internal__mark_iterator", "spot::internal::mark_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t = {"_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t", "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::iter_t *|spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__dv_t = {"_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__dv_t", "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::dv_t *|spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::dv_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__state_iterator = {"_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__state_iterator", "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator *|spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::state_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__sv_t = {"_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__sv_t", "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::sv_t *|spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::sv_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__tv_t = {"_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__tv_t", "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::tv_t *|spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all >::tv_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t = {"_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t", "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::iter_t *|spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__dv_t = {"_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__dv_t", "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::dv_t *|spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::dv_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__state_iterator = {"_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__state_iterator", "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator *|spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::state_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__sv_t = {"_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__sv_t", "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::sv_t *|spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::sv_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__tv_t = {"_p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__tv_t", "spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::tv_t *|spot::internal::scc_edge_iterator< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc >::tv_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t = {"_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t", "spot::internal::scc_edges< spot::twa_graph::graph_t const,spot::internal::keep_all > *|spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_all > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t = {"_p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t", "spot::internal::scc_edges< spot::twa_graph::graph_t const,spot::internal::keep_inner_scc > *|spot::internal::scc_edges< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > const,spot::internal::keep_inner_scc > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t = {"_p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t", "spot::internal::state_out< spot::kripke_graph::graph_t > *|spot::internal::state_out< spot::digraph< spot::kripke_graph_state,void > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t = {"_p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t", "spot::internal::state_out< spot::twa_graph::graph_t > *|spot::internal::state_out< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__internal__succ_iterator = {"_p_spot__internal__succ_iterator", "spot::internal::succ_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__isomorphism_checker = {"_p_spot__isomorphism_checker", "spot::isomorphism_checker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__kripke = {"_p_spot__kripke", "spot::kripke *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__kripke_graph = {"_p_spot__kripke_graph", "spot::kripke_graph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__kripke_graph_state = {"_p_spot__kripke_graph_state", "spot::kripke_graph_state *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__kripke_graph_succ_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t = {"_p_spot__kripke_graph_succ_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t", "spot::kripke_graph_succ_iterator< spot::kripke_graph::graph_t > *|spot::kripke_graph_succ_iterator< spot::digraph< spot::kripke_graph_state,void > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__kripke_succ_iterator = {"_p_spot__kripke_succ_iterator", "spot::kripke_succ_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__language_containment_checker = {"_p_spot__language_containment_checker", "spot::language_containment_checker *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__location = {"_p_spot__location", "spot::location *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__mealy_like = {"_p_spot__mealy_like", "spot::mealy_like *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__minato_isop = {"_p_spot__minato_isop", "spot::minato_isop *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__nca_st_info = {"_p_spot__nca_st_info", "spot::nca_st_info *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__option_map = {"_p_spot__option_map", "spot::option_map *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__outedge_combiner = {"_p_spot__outedge_combiner", "spot::outedge_combiner *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__output_aborter = {"_p_spot__output_aborter", "spot::output_aborter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__parallel_policy = {"_p_spot__parallel_policy", "spot::parallel_policy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__parse_aut_error_list = {"_p_spot__parse_aut_error_list", "spot::parse_aut_error_list *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__parse_error = {"_p_spot__parse_error", "spot::parse_error *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__parse_error_list = {"_p_spot__parse_error_list", "spot::parse_error_list *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__parsed_aut = {"_p_spot__parsed_aut", "spot::parsed_aut *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__parsed_formula = {"_p_spot__parsed_formula", "spot::parsed_formula *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__postprocessor = {"_p_spot__postprocessor", "spot::postprocessor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__power_map = {"_p_spot__power_map", "spot::power_map *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__printable_acc_cond = {"_p_spot__printable_acc_cond", "spot::printable_acc_cond *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__printable_formula = {"_p_spot__printable_formula", "spot::printable_formula *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__printable_long_size = {"_p_spot__printable_long_size", "spot::printable_long_size *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__printable_scc_info = {"_p_spot__printable_scc_info", "spot::printable_scc_info *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__printable_size = {"_p_spot__printable_size", "spot::printable_size *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__randltlgenerator = {"_p_spot__randltlgenerator", "spot::randltlgenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__random_boolean = {"_p_spot__random_boolean", "spot::random_boolean *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__random_formula = {"_p_spot__random_formula", "spot::random_formula *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__random_ltl = {"_p_spot__random_ltl", "spot::random_ltl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__random_psl = {"_p_spot__random_psl", "spot::random_psl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__random_sere = {"_p_spot__random_sere", "spot::random_sere *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__reduce_parity_data = {"_p_spot__reduce_parity_data", "spot::reduce_parity_data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__remove_ap = {"_p_spot__remove_ap", "spot::remove_ap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__rs_pairs_view = {"_p_spot__rs_pairs_view", "spot::rs_pairs_view *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__scc_and_mark_filter = {"_p_spot__scc_and_mark_filter", "spot::scc_and_mark_filter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__scc_info = {"_p_spot__scc_info", "spot::scc_info *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__scc_info_node = {"_p_spot__scc_info_node", "spot::scc_info_node *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__set_state = {"_p_spot__set_state", "spot::set_state *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__stat_printer = {"_p_spot__stat_printer", "spot::stat_printer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__state = {"_p_spot__state", "spot::state *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__state_product = {"_p_spot__state_product", "spot::state_product *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__state_ptr_equal = {"_p_spot__state_ptr_equal", "spot::state_ptr_equal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__state_ptr_hash = {"_p_spot__state_ptr_hash", "spot::state_ptr_hash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__state_ptr_less_than = {"_p_spot__state_ptr_less_than", "spot::state_ptr_less_than *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__state_shared_ptr_equal = {"_p_spot__state_shared_ptr_equal", "spot::state_shared_ptr_equal *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__state_shared_ptr_hash = {"_p_spot__state_shared_ptr_hash", "spot::state_shared_ptr_hash *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__state_shared_ptr_less_than = {"_p_spot__state_shared_ptr_less_than", "spot::state_shared_ptr_less_than *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__state_ta_explicit = {"_p_spot__state_ta_explicit", "spot::state_ta_explicit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__state_unicity_table = {"_p_spot__state_unicity_table", "spot::state_unicity_table *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__synthesis_info = {"_p_spot__synthesis_info", "spot::synthesis_info *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__ta = {"_p_spot__ta", "spot::ta *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__ta_explicit = {"_p_spot__ta_explicit", "spot::ta_explicit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__ta_explicit_succ_iterator = {"_p_spot__ta_explicit_succ_iterator", "spot::ta_explicit_succ_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__ta_statistics = {"_p_spot__ta_statistics", "spot::ta_statistics *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__ta_succ_iterator = {"_p_spot__ta_succ_iterator", "spot::ta_succ_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__taa_succ_iterator = {"_p_spot__taa_succ_iterator", "spot::taa_succ_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__taa_tgba = {"_p_spot__taa_tgba", "spot::taa_tgba *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__taa_tgba__transition = {"_p_spot__taa_tgba__transition", "spot::taa_tgba::transition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__taa_tgba_formula = {"_p_spot__taa_tgba_formula", "spot::taa_tgba_formula *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__taa_tgba_string = {"_p_spot__taa_tgba_string", "spot::taa_tgba_string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__tgta = {"_p_spot__tgta", "spot::tgta *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__tgta_explicit = {"_p_spot__tgta_explicit", "spot::tgta_explicit *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__tl_simplifier = {"_p_spot__tl_simplifier", "spot::tl_simplifier *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__tl_simplifier_options = {"_p_spot__tl_simplifier_options", "spot::tl_simplifier_options *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__to_parity_data = {"_p_spot__to_parity_data", "spot::to_parity_data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__to_parity_options = {"_p_spot__to_parity_options", "spot::to_parity_options *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__translator = {"_p_spot__translator", "spot::translator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__trival = {"_p_spot__trival", "spot::trival *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa = {"_p_spot__twa", "spot::twa *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa__prop_set = {"_p_spot__twa__prop_set", "spot::twa::prop_set *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_graph = {"_p_spot__twa_graph", "spot::twa_graph *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_graph_edge_data = {"_p_spot__twa_graph_edge_data", "spot::twa_graph_edge_data *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_graph_state = {"_p_spot__twa_graph_state", "spot::twa_graph_state *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_product = {"_p_spot__twa_product", "spot::twa_product *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_product_init = {"_p_spot__twa_product_init", "spot::twa_product_init *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_run = {"_p_spot__twa_run", "spot::twa_run *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_run__step = {"_p_spot__twa_run__step", "std::list< spot::twa_run::step >::value_type *|spot::twa_run::step *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_statistics = {"_p_spot__twa_statistics", "spot::twa_statistics *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_sub_statistics = {"_p_spot__twa_sub_statistics", "spot::twa_sub_statistics *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_succ_iterator = {"_p_spot__twa_succ_iterator", "spot::twa_succ_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_univ_remover = {"_p_spot__twa_univ_remover", "spot::twa_univ_remover *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__twa_word = {"_p_spot__twa_word", "spot::twa_word *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__unabbreviator = {"_p_spot__unabbreviator", "spot::unabbreviator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__univ_remover_state = {"_p_spot__univ_remover_state", "spot::univ_remover_state *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_spot__zielonka_tree = {"_p_spot__zielonka_tree", "spot::zielonka_tree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_state = {"_p_state", "state *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_state_iterator = {"_p_state_iterator", "state_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_state_num = {"_p_state_num", "state_num *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_state_set = {"_p_state_set", "state_set *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_state_storage_t = {"_p_state_storage_t", "state_storage_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_state_vector = {"_p_state_vector", "state_vector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_states_set_t = {"_p_states_set_t", "states_set_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_bdd_t = {"_p_std__allocatorT_bdd_t", "std::list< bdd >::allocator_type *|std::vector< bdd >::allocator_type *|std::allocator< bdd > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_bool_t = {"_p_std__allocatorT_bool_t", "std::vector< bool >::allocator_type *|std::allocator< bool > *", 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_spot__acc_cond__acc_code_t = {"_p_std__allocatorT_spot__acc_cond__acc_code_t", "std::vector< spot::acc_cond::acc_code >::allocator_type *|std::allocator< spot::acc_cond::acc_code > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_spot__acc_cond__rs_pair_t = {"_p_std__allocatorT_spot__acc_cond__rs_pair_t", "std::vector< spot::acc_cond::rs_pair >::allocator_type *|std::allocator< spot::acc_cond::rs_pair > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_spot__acc_cond_t = {"_p_std__allocatorT_spot__acc_cond_t", "std::vector< spot::acc_cond >::allocator_type *|std::allocator< spot::acc_cond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_spot__formula_t = {"_p_std__allocatorT_spot__formula_t", "std::vector< spot::formula >::allocator_type *|std::allocator< spot::formula > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t = {"_p_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t", "std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > >::allocator_type *|std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_spot__twa_run__step_t = {"_p_std__allocatorT_spot__twa_run__step_t", "std::list< spot::twa_run::step >::allocator_type *|std::allocator< spot::twa_run::step > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t = {"_p_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t", "std::map< spot::formula,spot::formula >::allocator_type *|std::allocator< std::pair< spot::formula const,spot::formula > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_std__string_bdd_t_t = {"_p_std__allocatorT_std__pairT_std__string_bdd_t_t", "std::vector< std::pair< std::string,bdd > >::allocator_type *|std::allocator< std::pair< std::string,bdd > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t = {"_p_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t", "std::vector< std::pair< unsigned int,unsigned int > >::allocator_type *|std::allocator< std::pair< unsigned int,unsigned int > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t = {"_p_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t", "std::vector< std::shared_ptr< spot::twa_graph > >::allocator_type *|std::allocator< std::shared_ptr< spot::twa_graph > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__allocatorT_std__string_t", "std::list< std::string >::allocator_type *|std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 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__conditionalT_std__is_constT_spot__digraphT_spot__kripke_graph_state_void_t_t__value_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_const_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_t__type = {"_p_std__conditionalT_std__is_constT_spot__digraphT_spot__kripke_graph_state_void_t_t__value_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_const_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_t__type", "spot::internal::all_trans< spot::digraph< spot::kripke_graph_state,void > >::tv_t *|std::conditional< std::is_const< spot::digraph< spot::kripke_graph_state,void > >::value,spot::digraph< spot::kripke_graph_state,void >::edge_vector_t const,spot::digraph< spot::kripke_graph_state,void >::edge_vector_t >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__conditionalT_std__is_constT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t__value_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_const_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_t__type = {"_p_std__conditionalT_std__is_constT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t__value_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_const_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_t__type", "spot::internal::all_trans< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::tv_t *|std::conditional< std::is_const< spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data > >::value,spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data >::edge_vector_t const,spot::digraph< spot::twa_graph_state,spot::twa_graph_edge_data >::edge_vector_t >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_std__string_fintF_t = {"_p_std__functionT_std__string_fintF_t", "std::function< std::string (int) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__functionT_void_fstd__ostream_R_intF_t = {"_p_std__functionT_void_fstd__ostream_R_intF_t", "std::function< void (std::ostream &,int) > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__initializer_listT_unsigned_int_t = {"_p_std__initializer_listT_unsigned_int_t", "std::initializer_list< spot::twa_graph::state_num > *|std::initializer_list< unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__lessT_spot__formula_t = {"_p_std__lessT_spot__formula_t", "std::less< spot::formula > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__listT_bdd_std__allocatorT_bdd_t_t = {"_p_std__listT_bdd_std__allocatorT_bdd_t_t", "spot::twa_word::seq_t *|std::list< bdd,std::allocator< bdd > > *|std::list< bdd > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t = {"_p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t", "spot::twa_run::steps *|std::list< spot::twa_run::step,std::allocator< spot::twa_run::step > > *|std::list< spot::twa_run::step > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__listT_std__string_std__allocatorT_std__string_t_t = {"_p_std__listT_std__string_std__allocatorT_std__string_t_t", "std::list< std::string,std::allocator< std::string > > *|std::list< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t = {"_p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t", "spot::bdd_dict::fv_map *|std::map< spot::formula,int,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t = {"_p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t", "spot::relabeling_map *|std::map< spot::formula,spot::formula,std::less< spot::formula >,std::allocator< std::pair< spot::formula const,spot::formula > > > *|std::map< spot::formula,spot::formula > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__mapT_std__string_const_spot__formula_std__lessT_std__string_const_t_std__allocatorT_std__pairT_std__string_const_const_spot__formula_t_t_t = {"_p_std__mapT_std__string_const_spot__formula_std__lessT_std__string_const_t_std__allocatorT_std__pairT_std__string_const_const_spot__formula_t_t_t", "spot::declarative_environment::prop_map *|std::map< std::string const,spot::formula,std::less< std::string const >,std::allocator< std::pair< std::string const const,spot::formula > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__nullptr_t = {"_p_std__nullptr_t", "std::nullptr_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ofstream = {"_p_std__ofstream", "std::ofstream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__optionalT_spot__synthesis_info__bench_var_t = {"_p_std__optionalT_spot__synthesis_info__bench_var_t", "std::optional< spot::synthesis_info::bench_var > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ostringstream = {"_p_std__ostringstream", "std::ostringstream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_bool_spot__acc_cond__mark_t_t = {"_p_std__pairT_bool_spot__acc_cond__mark_t_t", "std::pair< bool,spot::acc_cond::mark_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_int_spot__acc_cond__acc_code_t = {"_p_std__pairT_int_spot__acc_cond__acc_code_t", "std::pair< int,spot::acc_cond::acc_code > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_int_spot__acc_cond_t = {"_p_std__pairT_int_spot__acc_cond_t", "std::pair< int,spot::acc_cond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t = {"_p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t", "std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t = {"_p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t", "std::pair< spot::formula,std::vector< std::string,std::allocator< std::string > > > *|std::pair< spot::formula,std::vector< std::string > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__string_bdd_t = {"_p_std__pairT_std__string_bdd_t", "std::vector< std::pair< std::string,bdd > >::value_type *|std::pair< std::string,bdd > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t_std__vectorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_std__allocatorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_t_t_t = {"_p_std__pairT_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t_std__vectorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_std__allocatorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_t_t_t", "std::pair< std::vector< spot::formula,std::allocator< spot::formula > >,std::vector< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > >,std::allocator< std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_unsigned_int_unsigned_int_t = {"_p_std__pairT_unsigned_int_unsigned_int_t", "std::pair< unsigned int,unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__runtime_error = {"_p_std__runtime_error", "std::runtime_error *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t = {"_p_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t", "std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t = {"_p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t", "spot::atomic_prop_set *|std::set< spot::formula,std::less< spot::formula >,std::allocator< spot::formula > > *|std::set< spot::formula > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_spot__state_const_p_spot__state_ptr_less_than_std__allocatorT_spot__state_const_p_t_t = {"_p_std__setT_spot__state_const_p_spot__state_ptr_less_than_std__allocatorT_spot__state_const_p_t_t", "spot::ta::const_states_set_t *|std::set< spot::state const *,spot::state_ptr_less_than,std::allocator< spot::state const * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_spot__state_p_spot__state_ptr_less_than_std__allocatorT_spot__state_p_t_t = {"_p_std__setT_spot__state_p_spot__state_ptr_less_than_std__allocatorT_spot__state_p_t_t", "spot::ta::states_set_t *|std::set< spot::state *,spot::state_ptr_less_than,std::allocator< spot::state * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t = {"_p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t", "spot::taa_tgba::state_set *|std::set< std::list< spot::taa_tgba::transition *,std::allocator< spot::taa_tgba::transition * > > *,std::less< std::list< spot::taa_tgba::transition *,std::allocator< spot::taa_tgba::transition * > > * >,std::allocator< std::list< spot::taa_tgba::transition *,std::allocator< spot::taa_tgba::transition * > > * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t = {"_p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t", "spot::power_map::power_state *|std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__aig_const_t = {"_p_std__shared_ptrT_spot__aig_const_t", "spot::const_aig_ptr *|std::shared_ptr< spot::aig const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__aig_t = {"_p_std__shared_ptrT_spot__aig_t", "spot::aig_ptr *|std::shared_ptr< spot::aig > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__bdd_dict_t = {"_p_std__shared_ptrT_spot__bdd_dict_t", "spot::bdd_dict_ptr *|std::shared_ptr< spot::bdd_dict > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__dstar_aut_t = {"_p_std__shared_ptrT_spot__dstar_aut_t", "std::shared_ptr< spot::dstar_aut > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__emptiness_check_instantiator_t = {"_p_std__shared_ptrT_spot__emptiness_check_instantiator_t", "spot::emptiness_check_instantiator_ptr *|std::shared_ptr< spot::emptiness_check_instantiator > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__emptiness_check_result_t = {"_p_std__shared_ptrT_spot__emptiness_check_result_t", "spot::emptiness_check_result_ptr *|std::shared_ptr< spot::emptiness_check_result > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__emptiness_check_t = {"_p_std__shared_ptrT_spot__emptiness_check_t", "spot::emptiness_check_ptr *|std::shared_ptr< spot::emptiness_check > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__fair_kripke_t = {"_p_std__shared_ptrT_spot__fair_kripke_t", "std::shared_ptr< spot::fair_kripke > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__kripke_const_t = {"_p_std__shared_ptrT_spot__kripke_const_t", "spot::const_kripke_ptr *|std::shared_ptr< spot::kripke const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__kripke_graph_t = {"_p_std__shared_ptrT_spot__kripke_graph_t", "spot::kripke_graph_ptr *|std::shared_ptr< spot::kripke_graph > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__kripke_t = {"_p_std__shared_ptrT_spot__kripke_t", "spot::kripke_ptr *|std::shared_ptr< spot::kripke > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__parsed_aut_const_t = {"_p_std__shared_ptrT_spot__parsed_aut_const_t", "spot::const_parsed_aut_ptr *|std::shared_ptr< spot::parsed_aut const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__parsed_aut_t = {"_p_std__shared_ptrT_spot__parsed_aut_t", "spot::parsed_aut_ptr *|std::shared_ptr< spot::parsed_aut > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__state_const_t = {"_p_std__shared_ptrT_spot__state_const_t", "spot::shared_state *|std::shared_ptr< spot::state const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__ta_const_t = {"_p_std__shared_ptrT_spot__ta_const_t", "spot::const_ta_ptr *|std::shared_ptr< spot::ta const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__ta_explicit_const_t = {"_p_std__shared_ptrT_spot__ta_explicit_const_t", "spot::const_ta_explicit_ptr *|std::shared_ptr< spot::ta_explicit const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__ta_explicit_t = {"_p_std__shared_ptrT_spot__ta_explicit_t", "spot::ta_explicit_ptr *|std::shared_ptr< spot::ta_explicit > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__ta_product_t = {"_p_std__shared_ptrT_spot__ta_product_t", "std::shared_ptr< spot::ta_product > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__ta_t = {"_p_std__shared_ptrT_spot__ta_t", "spot::ta_ptr *|std::shared_ptr< spot::ta > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__taa_tgba_formula_const_t = {"_p_std__shared_ptrT_spot__taa_tgba_formula_const_t", "spot::const_taa_tgba_formula_ptr *|std::shared_ptr< spot::taa_tgba_formula const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__taa_tgba_formula_t = {"_p_std__shared_ptrT_spot__taa_tgba_formula_t", "spot::taa_tgba_formula_ptr *|std::shared_ptr< spot::taa_tgba_formula > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__taa_tgba_string_const_t = {"_p_std__shared_ptrT_spot__taa_tgba_string_const_t", "spot::const_taa_tgba_string_ptr *|std::shared_ptr< spot::taa_tgba_string const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__taa_tgba_string_t = {"_p_std__shared_ptrT_spot__taa_tgba_string_t", "spot::taa_tgba_string_ptr *|std::shared_ptr< spot::taa_tgba_string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__taa_tgba_t = {"_p_std__shared_ptrT_spot__taa_tgba_t", "std::shared_ptr< spot::taa_tgba > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__tgbasl_t = {"_p_std__shared_ptrT_spot__tgbasl_t", "std::shared_ptr< spot::tgbasl > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__tgta_const_t = {"_p_std__shared_ptrT_spot__tgta_const_t", "spot::const_tgta_ptr *|std::shared_ptr< spot::tgta const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__tgta_explicit_const_t = {"_p_std__shared_ptrT_spot__tgta_explicit_const_t", "spot::const_tgta_explicit_ptr *|std::shared_ptr< spot::tgta_explicit const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__tgta_explicit_t = {"_p_std__shared_ptrT_spot__tgta_explicit_t", "spot::tgta_explicit_ptr *|std::shared_ptr< spot::tgta_explicit > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__tgta_t = {"_p_std__shared_ptrT_spot__tgta_t", "spot::tgta_ptr *|std::shared_ptr< spot::tgta > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_const_t = {"_p_std__shared_ptrT_spot__twa_const_t", "spot::const_twa_ptr *|std::shared_ptr< spot::twa const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_graph_const_t = {"_p_std__shared_ptrT_spot__twa_graph_const_t", "spot::const_twa_graph_ptr *|std::shared_ptr< spot::twa_graph const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_graph_t = {"_p_std__shared_ptrT_spot__twa_graph_t", "spot::twa_graph_ptr *|std::shared_ptr< spot::twa_graph > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_product_const_t = {"_p_std__shared_ptrT_spot__twa_product_const_t", "spot::const_twa_product_ptr *|std::shared_ptr< spot::twa_product const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_product_init_t = {"_p_std__shared_ptrT_spot__twa_product_init_t", "std::shared_ptr< spot::twa_product_init > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_product_t = {"_p_std__shared_ptrT_spot__twa_product_t", "spot::twa_product_ptr *|std::shared_ptr< spot::twa_product > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_run_const_t = {"_p_std__shared_ptrT_spot__twa_run_const_t", "spot::const_twa_run_ptr *|std::shared_ptr< spot::twa_run const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_run_t = {"_p_std__shared_ptrT_spot__twa_run_t", "spot::twa_run_ptr *|std::shared_ptr< spot::twa_run > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_t = {"_p_std__shared_ptrT_spot__twa_t", "spot::twa_ptr *|std::shared_ptr< spot::twa > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_univ_remover_t = {"_p_std__shared_ptrT_spot__twa_univ_remover_t", "spot::twa_univ_remover_ptr *|std::shared_ptr< spot::twa_univ_remover > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__shared_ptrT_spot__twa_word_t = {"_p_std__shared_ptrT_spot__twa_word_t", "spot::twa_word_ptr *|std::shared_ptr< spot::twa_word > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__tupleT_int_spot__acc_cond__acc_code_spot__acc_cond__acc_code_t = {"_p_std__tupleT_int_spot__acc_cond__acc_code_spot__acc_cond__acc_code_t", "std::tuple< int,spot::acc_cond::acc_code,spot::acc_cond::acc_code > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__tupleT_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t_std__vectorT_std__pairT_unsigned_int_bdd_t_std__allocatorT_std__pairT_unsigned_int_bdd_t_t_t_std__vectorT_bdd_std__allocatorT_bdd_t_t_t = {"_p_std__tupleT_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t_std__vectorT_std__pairT_unsigned_int_bdd_t_std__allocatorT_std__pairT_unsigned_int_bdd_t_t_t_std__vectorT_bdd_std__allocatorT_bdd_t_t_t", "spot::aig::safe_stash *|std::tuple< std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > >,std::vector< std::pair< unsigned int,bdd >,std::allocator< std::pair< unsigned int,bdd > > >,std::vector< bdd,std::allocator< bdd > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__tupleT_t = {"_p_std__tupleT_t", "std::tuple< > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unordered_setT_spot__state_const_p_spot__state_ptr_hash_spot__state_ptr_equal_t = {"_p_std__unordered_setT_spot__state_const_p_spot__state_ptr_hash_spot__state_ptr_equal_t", "spot::state_set *|std::unordered_set< spot::state const *,spot::state_ptr_hash,spot::state_ptr_equal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unordered_setT_std__shared_ptrT_spot__state_const_t_spot__state_shared_ptr_hash_spot__state_shared_ptr_equal_t = {"_p_std__unordered_setT_std__shared_ptrT_spot__state_const_t_spot__state_shared_ptr_hash_spot__state_shared_ptr_equal_t", "spot::shared_state_set *|std::unordered_set< std::shared_ptr< spot::state const >,spot::state_shared_ptr_hash,spot::state_shared_ptr_equal > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_bdd_std__allocatorT_bdd_t_t = {"_p_std__vectorT_bdd_std__allocatorT_bdd_t_t", "std::vector< bdd,std::allocator< bdd > > *|std::vector< bdd > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t = {"_p_std__vectorT_bool_std__allocatorT_bool_t_t", "spot::region_t *|std::vector< bool,std::allocator< bool > > *|std::vector< bool > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t = {"_p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t", "std::vector< spot::acc_cond::acc_code,std::allocator< spot::acc_cond::acc_code > > *|std::vector< spot::acc_cond::acc_code > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__acc_cond__mark_t_std__allocatorT_spot__acc_cond__mark_t_t_t = {"_p_std__vectorT_spot__acc_cond__mark_t_std__allocatorT_spot__acc_cond__mark_t_t_t", "std::vector< spot::acc_cond::mark_t,std::allocator< spot::acc_cond::mark_t > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t = {"_p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t", "std::vector< spot::acc_cond::rs_pair,std::allocator< spot::acc_cond::rs_pair > > *|std::vector< spot::acc_cond::rs_pair > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t = {"_p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t", "std::vector< spot::acc_cond,std::allocator< spot::acc_cond > > *|std::vector< spot::acc_cond > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__bdd_dict__bdd_info_std__allocatorT_spot__bdd_dict__bdd_info_t_t = {"_p_std__vectorT_spot__bdd_dict__bdd_info_std__allocatorT_spot__bdd_dict__bdd_info_t_t", "spot::bdd_dict::bdd_info_map *|std::vector< spot::bdd_dict::bdd_info,std::allocator< spot::bdd_dict::bdd_info > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t = {"_p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t", "std::vector< spot::formula,std::allocator< spot::formula > > *|std::vector< spot::formula > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t = {"_p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t", "spot::kripke_graph::state_vector *|std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > >,std::allocator< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > > *|std::vector< spot::internal::distate_storage< unsigned int,spot::internal::boxed_label< spot::kripke_graph_state,false > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t = {"_p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t", "std::vector< spot::mealy_like,std::allocator< spot::mealy_like > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__nca_st_info_p_std__allocatorT_spot__nca_st_info_p_t_t = {"_p_std__vectorT_spot__nca_st_info_p_std__allocatorT_spot__nca_st_info_p_t_t", "spot::vect_nca_info *|std::vector< spot::nca_st_info *,std::allocator< spot::nca_st_info * > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator = {"_p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator", "std::vector< spot::scc_info::scc_node,std::allocator< spot::scc_info::scc_node > >::const_iterator *|std::vector< spot::scc_info_node,std::allocator< spot::scc_info_node > >::const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_reverse_iterator = {"_p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_reverse_iterator", "std::vector< spot::scc_info::scc_node,std::allocator< spot::scc_info::scc_node > >::const_reverse_iterator *|std::vector< spot::scc_info_node,std::allocator< spot::scc_info_node > >::const_reverse_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_spot__zielonka_tree__zielonka_node_std__allocatorT_spot__zielonka_tree__zielonka_node_t_t = {"_p_std__vectorT_spot__zielonka_tree__zielonka_node_std__allocatorT_spot__zielonka_tree__zielonka_node_t_t", "std::vector< spot::zielonka_tree::zielonka_node,std::allocator< spot::zielonka_tree::zielonka_node > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_std__allocatorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_t_t = {"_p_std__vectorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_std__allocatorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_t_t", "std::vector< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t >,std::allocator< std::pair< spot::acc_cond::mark_t,spot::acc_cond::mark_t > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t = {"_p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t", "spot::hoa_alias_formater::aliases_t *|std::vector< std::pair< std::string,bdd >,std::allocator< std::pair< std::string,bdd > > > *|std::vector< std::pair< std::string,bdd > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t = {"_p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t", "spot::product_states *|std::vector< std::pair< unsigned int,unsigned int >,std::allocator< std::pair< unsigned int,unsigned int > > > *|std::vector< std::pair< unsigned int,unsigned int > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_std__allocatorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_t_t = {"_p_std__vectorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_std__allocatorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_t_t", "std::vector< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > >,std::allocator< std::set< spot::acc_cond::mark_t,std::less< spot::acc_cond::mark_t >,std::allocator< spot::acc_cond::mark_t > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_std__allocatorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_t_t = {"_p_std__vectorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_std__allocatorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_t_t", "std::vector< spot::power_map::power_state,std::allocator< spot::power_map::power_state > > *|std::vector< std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > >,std::allocator< std::set< unsigned int,std::less< unsigned int >,std::allocator< unsigned int > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t = {"_p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t", "std::vector< spot::twa_graph_ptr > *|std::vector< spot::twa_graph_ptr,std::allocator< spot::twa_graph_ptr > > *|std::vector< std::shared_ptr< spot::twa_graph >,std::allocator< std::shared_ptr< spot::twa_graph > > > *|std::vector< std::shared_ptr< spot::twa_graph > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_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_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t = {"_p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t", "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t = {"_p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t", "std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t = {"_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t", "spot::strategy_t *|std::vector< unsigned int,std::allocator< unsigned int > > *|std::vector< unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_steps = {"_p_steps", "steps *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_sv_t = {"_p_sv_t", "sv_t *", 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_tv_t = {"_p_tv_t", "tv_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "uint8_t *|uint_fast8_t *|uint_least8_t *|unsigned char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uint32_t *|uint_fast16_t *|uint_fast32_t *|uint_least32_t *|uintptr_t *|unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint64_t *|uint_fast64_t *|uint_least64_t *|uintmax_t *|unsigned long long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "uint16_t *|uint_least16_t *|unsigned short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_statistics = {"_p_unsigned_statistics", "unsigned_statistics *", 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_vf_map = {"_p_vf_map", "vf_map *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_aliases_t,
  &_swigt__p_allocator_type,
  &_swigt__p_bdd,
  &_swigt__p_bdd_info_map,
  &_swigt__p_bitvect,
  &_swigt__p_bool,
  &_swigt__p_char,
  &_swigt__p_const_reference,
  &_swigt__p_const_states_set_t,
  &_swigt__p_data_t,
  &_swigt__p_difference_type,
  &_swigt__p_dv_t,
  &_swigt__p_ec_statistics,
  &_swigt__p_edge,
  &_swigt__p_edge_filter,
  &_swigt__p_edge_filter_choice,
  &_swigt__p_edge_storage_t,
  &_swigt__p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice,
  &_swigt__p_first_type,
  &_swigt__p_fixed_size_poolT_pool_type__Safe_t,
  &_swigt__p_fnode,
  &_swigt__p_fv_map,
  &_swigt__p_graph_t,
  &_swigt__p_int,
  &_swigt__p_iter_t,
  &_swigt__p_iterator_category,
  &_swigt__p_key_type,
  &_swigt__p_long_long,
  &_swigt__p_mapped_type,
  &_swigt__p_output_aborter,
  &_swigt__p_output_pref,
  &_swigt__p_p_PyObject,
  &_swigt__p_p_char,
  &_swigt__p_p_f_r_q_const__std__vector__unsigned_int_std__allocator__unsigned_int_____p_void__void,
  &_swigt__p_power_state,
  &_swigt__p_prop_map,
  &_swigt__p_ref_set,
  &_swigt__p_repr_t,
  &_swigt__p_rs_pairs,
  &_swigt__p_safe_point,
  &_swigt__p_safe_stash,
  &_swigt__p_scc_node,
  &_swigt__p_scc_succs,
  &_swigt__p_second_type,
  &_swigt__p_seq_t,
  &_swigt__p_short,
  &_swigt__p_signed_char,
  &_swigt__p_size_type,
  &_swigt__p_spot__acc_cond,
  &_swigt__p_spot__acc_cond__acc_code,
  &_swigt__p_spot__acc_cond__acc_word,
  &_swigt__p_spot__acc_cond__mark_t,
  &_swigt__p_spot__acc_cond__rs_pair,
  &_swigt__p_spot__acd,
  &_swigt__p_spot__aig,
  &_swigt__p_spot__automaton_parser_options,
  &_swigt__p_spot__automaton_stream_parser,
  &_swigt__p_spot__bdd_dict,
  &_swigt__p_spot__declarative_environment,
  &_swigt__p_spot__default_environment,
  &_swigt__p_spot__digraphT_spot__kripke_graph_state_void_t,
  &_swigt__p_spot__digraphT_spot__kripke_graph_state_void_t__edge,
  &_swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t,
  &_swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge,
  &_swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_storage_t,
  &_swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__state_storage_t,
  &_swigt__p_spot__emptiness_check,
  &_swigt__p_spot__emptiness_check_instantiator,
  &_swigt__p_spot__emptiness_check_result,
  &_swigt__p_spot__environment,
  &_swigt__p_spot__fair_kripke,
  &_swigt__p_spot__fair_kripke_succ_iterator,
  &_swigt__p_spot__formula,
  &_swigt__p_spot__game_relabeling_map,
  &_swigt__p_spot__hoa_alias_formater,
  &_swigt__p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t,
  &_swigt__p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
  &_swigt__p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t,
  &_swigt__p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
  &_swigt__p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t,
  &_swigt__p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t,
  &_swigt__p_spot__internal__boxed_labelT_void_true_t,
  &_swigt__p_spot__internal__const_universal_dests,
  &_swigt__p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t,
  &_swigt__p_spot__internal__edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t,
  &_swigt__p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
  &_swigt__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t,
  &_swigt__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t,
  &_swigt__p_spot__internal__keep_all,
  &_swigt__p_spot__internal__keep_inner_scc,
  &_swigt__p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
  &_swigt__p_spot__internal__mark_container,
  &_swigt__p_spot__internal__mark_iterator,
  &_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t,
  &_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__dv_t,
  &_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__state_iterator,
  &_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__sv_t,
  &_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__tv_t,
  &_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t,
  &_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__dv_t,
  &_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__state_iterator,
  &_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__sv_t,
  &_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__tv_t,
  &_swigt__p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t,
  &_swigt__p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t,
  &_swigt__p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t,
  &_swigt__p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
  &_swigt__p_spot__internal__succ_iterator,
  &_swigt__p_spot__isomorphism_checker,
  &_swigt__p_spot__kripke,
  &_swigt__p_spot__kripke_graph,
  &_swigt__p_spot__kripke_graph_state,
  &_swigt__p_spot__kripke_graph_succ_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t,
  &_swigt__p_spot__kripke_succ_iterator,
  &_swigt__p_spot__language_containment_checker,
  &_swigt__p_spot__location,
  &_swigt__p_spot__mealy_like,
  &_swigt__p_spot__minato_isop,
  &_swigt__p_spot__nca_st_info,
  &_swigt__p_spot__option_map,
  &_swigt__p_spot__outedge_combiner,
  &_swigt__p_spot__output_aborter,
  &_swigt__p_spot__parallel_policy,
  &_swigt__p_spot__parse_aut_error_list,
  &_swigt__p_spot__parse_error,
  &_swigt__p_spot__parse_error_list,
  &_swigt__p_spot__parsed_aut,
  &_swigt__p_spot__parsed_formula,
  &_swigt__p_spot__postprocessor,
  &_swigt__p_spot__power_map,
  &_swigt__p_spot__printable_acc_cond,
  &_swigt__p_spot__printable_formula,
  &_swigt__p_spot__printable_long_size,
  &_swigt__p_spot__printable_scc_info,
  &_swigt__p_spot__printable_size,
  &_swigt__p_spot__randltlgenerator,
  &_swigt__p_spot__random_boolean,
  &_swigt__p_spot__random_formula,
  &_swigt__p_spot__random_ltl,
  &_swigt__p_spot__random_psl,
  &_swigt__p_spot__random_sere,
  &_swigt__p_spot__reduce_parity_data,
  &_swigt__p_spot__remove_ap,
  &_swigt__p_spot__rs_pairs_view,
  &_swigt__p_spot__scc_and_mark_filter,
  &_swigt__p_spot__scc_info,
  &_swigt__p_spot__scc_info_node,
  &_swigt__p_spot__set_state,
  &_swigt__p_spot__stat_printer,
  &_swigt__p_spot__state,
  &_swigt__p_spot__state_product,
  &_swigt__p_spot__state_ptr_equal,
  &_swigt__p_spot__state_ptr_hash,
  &_swigt__p_spot__state_ptr_less_than,
  &_swigt__p_spot__state_shared_ptr_equal,
  &_swigt__p_spot__state_shared_ptr_hash,
  &_swigt__p_spot__state_shared_ptr_less_than,
  &_swigt__p_spot__state_ta_explicit,
  &_swigt__p_spot__state_unicity_table,
  &_swigt__p_spot__synthesis_info,
  &_swigt__p_spot__ta,
  &_swigt__p_spot__ta_explicit,
  &_swigt__p_spot__ta_explicit_succ_iterator,
  &_swigt__p_spot__ta_statistics,
  &_swigt__p_spot__ta_succ_iterator,
  &_swigt__p_spot__taa_succ_iterator,
  &_swigt__p_spot__taa_tgba,
  &_swigt__p_spot__taa_tgba__transition,
  &_swigt__p_spot__taa_tgba_formula,
  &_swigt__p_spot__taa_tgba_string,
  &_swigt__p_spot__tgta,
  &_swigt__p_spot__tgta_explicit,
  &_swigt__p_spot__tl_simplifier,
  &_swigt__p_spot__tl_simplifier_options,
  &_swigt__p_spot__to_parity_data,
  &_swigt__p_spot__to_parity_options,
  &_swigt__p_spot__translator,
  &_swigt__p_spot__trival,
  &_swigt__p_spot__twa,
  &_swigt__p_spot__twa__prop_set,
  &_swigt__p_spot__twa_graph,
  &_swigt__p_spot__twa_graph_edge_data,
  &_swigt__p_spot__twa_graph_state,
  &_swigt__p_spot__twa_product,
  &_swigt__p_spot__twa_product_init,
  &_swigt__p_spot__twa_run,
  &_swigt__p_spot__twa_run__step,
  &_swigt__p_spot__twa_statistics,
  &_swigt__p_spot__twa_sub_statistics,
  &_swigt__p_spot__twa_succ_iterator,
  &_swigt__p_spot__twa_univ_remover,
  &_swigt__p_spot__twa_word,
  &_swigt__p_spot__unabbreviator,
  &_swigt__p_spot__univ_remover_state,
  &_swigt__p_spot__zielonka_tree,
  &_swigt__p_state,
  &_swigt__p_state_iterator,
  &_swigt__p_state_num,
  &_swigt__p_state_set,
  &_swigt__p_state_storage_t,
  &_swigt__p_state_vector,
  &_swigt__p_states_set_t,
  &_swigt__p_std__allocatorT_bdd_t,
  &_swigt__p_std__allocatorT_bool_t,
  &_swigt__p_std__allocatorT_int_t,
  &_swigt__p_std__allocatorT_spot__acc_cond__acc_code_t,
  &_swigt__p_std__allocatorT_spot__acc_cond__rs_pair_t,
  &_swigt__p_std__allocatorT_spot__acc_cond_t,
  &_swigt__p_std__allocatorT_spot__formula_t,
  &_swigt__p_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t,
  &_swigt__p_std__allocatorT_spot__twa_run__step_t,
  &_swigt__p_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t,
  &_swigt__p_std__allocatorT_std__pairT_std__string_bdd_t_t,
  &_swigt__p_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t,
  &_swigt__p_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t,
  &_swigt__p_std__allocatorT_std__string_t,
  &_swigt__p_std__allocatorT_unsigned_int_t,
  &_swigt__p_std__conditionalT_std__is_constT_spot__digraphT_spot__kripke_graph_state_void_t_t__value_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_const_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_t__type,
  &_swigt__p_std__conditionalT_std__is_constT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t__value_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_const_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_t__type,
  &_swigt__p_std__functionT_std__string_fintF_t,
  &_swigt__p_std__functionT_void_fstd__ostream_R_intF_t,
  &_swigt__p_std__initializer_listT_unsigned_int_t,
  &_swigt__p_std__invalid_argument,
  &_swigt__p_std__istream,
  &_swigt__p_std__lessT_spot__formula_t,
  &_swigt__p_std__listT_bdd_std__allocatorT_bdd_t_t,
  &_swigt__p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t,
  &_swigt__p_std__listT_std__string_std__allocatorT_std__string_t_t,
  &_swigt__p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t,
  &_swigt__p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t,
  &_swigt__p_std__mapT_std__string_const_spot__formula_std__lessT_std__string_const_t_std__allocatorT_std__pairT_std__string_const_const_spot__formula_t_t_t,
  &_swigt__p_std__nullptr_t,
  &_swigt__p_std__ofstream,
  &_swigt__p_std__optionalT_spot__synthesis_info__bench_var_t,
  &_swigt__p_std__ostream,
  &_swigt__p_std__ostringstream,
  &_swigt__p_std__pairT_bool_spot__acc_cond__mark_t_t,
  &_swigt__p_std__pairT_int_spot__acc_cond__acc_code_t,
  &_swigt__p_std__pairT_int_spot__acc_cond_t,
  &_swigt__p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t,
  &_swigt__p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t,
  &_swigt__p_std__pairT_std__string_bdd_t,
  &_swigt__p_std__pairT_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t_std__vectorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_std__allocatorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_t_t_t,
  &_swigt__p_std__pairT_unsigned_int_unsigned_int_t,
  &_swigt__p_std__runtime_error,
  &_swigt__p_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t,
  &_swigt__p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t,
  &_swigt__p_std__setT_spot__state_const_p_spot__state_ptr_less_than_std__allocatorT_spot__state_const_p_t_t,
  &_swigt__p_std__setT_spot__state_p_spot__state_ptr_less_than_std__allocatorT_spot__state_p_t_t,
  &_swigt__p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t,
  &_swigt__p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t,
  &_swigt__p_std__shared_ptrT_spot__aig_const_t,
  &_swigt__p_std__shared_ptrT_spot__aig_t,
  &_swigt__p_std__shared_ptrT_spot__bdd_dict_t,
  &_swigt__p_std__shared_ptrT_spot__dstar_aut_t,
  &_swigt__p_std__shared_ptrT_spot__emptiness_check_instantiator_t,
  &_swigt__p_std__shared_ptrT_spot__emptiness_check_result_t,
  &_swigt__p_std__shared_ptrT_spot__emptiness_check_t,
  &_swigt__p_std__shared_ptrT_spot__fair_kripke_t,
  &_swigt__p_std__shared_ptrT_spot__kripke_const_t,
  &_swigt__p_std__shared_ptrT_spot__kripke_graph_t,
  &_swigt__p_std__shared_ptrT_spot__kripke_t,
  &_swigt__p_std__shared_ptrT_spot__parsed_aut_const_t,
  &_swigt__p_std__shared_ptrT_spot__parsed_aut_t,
  &_swigt__p_std__shared_ptrT_spot__state_const_t,
  &_swigt__p_std__shared_ptrT_spot__ta_const_t,
  &_swigt__p_std__shared_ptrT_spot__ta_explicit_const_t,
  &_swigt__p_std__shared_ptrT_spot__ta_explicit_t,
  &_swigt__p_std__shared_ptrT_spot__ta_product_t,
  &_swigt__p_std__shared_ptrT_spot__ta_t,
  &_swigt__p_std__shared_ptrT_spot__taa_tgba_formula_const_t,
  &_swigt__p_std__shared_ptrT_spot__taa_tgba_formula_t,
  &_swigt__p_std__shared_ptrT_spot__taa_tgba_string_const_t,
  &_swigt__p_std__shared_ptrT_spot__taa_tgba_string_t,
  &_swigt__p_std__shared_ptrT_spot__taa_tgba_t,
  &_swigt__p_std__shared_ptrT_spot__tgbasl_t,
  &_swigt__p_std__shared_ptrT_spot__tgta_const_t,
  &_swigt__p_std__shared_ptrT_spot__tgta_explicit_const_t,
  &_swigt__p_std__shared_ptrT_spot__tgta_explicit_t,
  &_swigt__p_std__shared_ptrT_spot__tgta_t,
  &_swigt__p_std__shared_ptrT_spot__twa_const_t,
  &_swigt__p_std__shared_ptrT_spot__twa_graph_const_t,
  &_swigt__p_std__shared_ptrT_spot__twa_graph_t,
  &_swigt__p_std__shared_ptrT_spot__twa_product_const_t,
  &_swigt__p_std__shared_ptrT_spot__twa_product_init_t,
  &_swigt__p_std__shared_ptrT_spot__twa_product_t,
  &_swigt__p_std__shared_ptrT_spot__twa_run_const_t,
  &_swigt__p_std__shared_ptrT_spot__twa_run_t,
  &_swigt__p_std__shared_ptrT_spot__twa_t,
  &_swigt__p_std__shared_ptrT_spot__twa_univ_remover_t,
  &_swigt__p_std__shared_ptrT_spot__twa_word_t,
  &_swigt__p_std__tupleT_int_spot__acc_cond__acc_code_spot__acc_cond__acc_code_t,
  &_swigt__p_std__tupleT_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t_std__vectorT_std__pairT_unsigned_int_bdd_t_std__allocatorT_std__pairT_unsigned_int_bdd_t_t_t_std__vectorT_bdd_std__allocatorT_bdd_t_t_t,
  &_swigt__p_std__tupleT_t,
  &_swigt__p_std__unordered_setT_spot__state_const_p_spot__state_ptr_hash_spot__state_ptr_equal_t,
  &_swigt__p_std__unordered_setT_std__shared_ptrT_spot__state_const_t_spot__state_shared_ptr_hash_spot__state_shared_ptr_equal_t,
  &_swigt__p_std__vectorT_bdd_std__allocatorT_bdd_t_t,
  &_swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t,
  &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
  &_swigt__p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t,
  &_swigt__p_std__vectorT_spot__acc_cond__mark_t_std__allocatorT_spot__acc_cond__mark_t_t_t,
  &_swigt__p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t,
  &_swigt__p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t,
  &_swigt__p_std__vectorT_spot__bdd_dict__bdd_info_std__allocatorT_spot__bdd_dict__bdd_info_t_t,
  &_swigt__p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,
  &_swigt__p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t,
  &_swigt__p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t,
  &_swigt__p_std__vectorT_spot__nca_st_info_p_std__allocatorT_spot__nca_st_info_p_t_t,
  &_swigt__p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator,
  &_swigt__p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_reverse_iterator,
  &_swigt__p_std__vectorT_spot__zielonka_tree__zielonka_node_std__allocatorT_spot__zielonka_tree__zielonka_node_t_t,
  &_swigt__p_std__vectorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_std__allocatorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_t_t,
  &_swigt__p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t,
  &_swigt__p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t,
  &_swigt__p_std__vectorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_std__allocatorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_t_t,
  &_swigt__p_std__vectorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_std__allocatorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_t_t,
  &_swigt__p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t,
  &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  &_swigt__p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t,
  &_swigt__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t,
  &_swigt__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,
  &_swigt__p_steps,
  &_swigt__p_sv_t,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_tv_t,
  &_swigt__p_unsigned_char,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_long_long,
  &_swigt__p_unsigned_short,
  &_swigt__p_unsigned_statistics,
  &_swigt__p_value_type,
  &_swigt__p_vf_map,
  &_swigt__p_void,
};

static swig_cast_info _swigc__p_aliases_t[] = {  {&_swigt__p_aliases_t, 0, 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_bdd[] = {  {&_swigt__p_bdd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bdd_info_map[] = {  {&_swigt__p_bdd_info_map, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bitvect[] = {  {&_swigt__p_bitvect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 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_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_states_set_t[] = {  {&_swigt__p_const_states_set_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_data_t[] = {  {&_swigt__p_data_t, 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_dv_t[] = {  {&_swigt__p_dv_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ec_statistics[] = {  {&_swigt__p_ec_statistics, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_edge[] = {  {&_swigt__p_edge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_edge_filter[] = {  {&_swigt__p_edge_filter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_edge_filter_choice[] = {  {&_swigt__p_edge_filter_choice, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_edge_storage_t[] = {  {&_swigt__p_edge_storage_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice[] = {  {&_swigt__p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice, 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_fixed_size_poolT_pool_type__Safe_t[] = {  {&_swigt__p_fixed_size_poolT_pool_type__Safe_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_fnode[] = {  {&_swigt__p_fnode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_fv_map[] = {  {&_swigt__p_fv_map, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_graph_t[] = {  {&_swigt__p_graph_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iter_t[] = {  {&_swigt__p_iter_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iterator_category[] = {  {&_swigt__p_iterator_category, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_key_type[] = {  {&_swigt__p_key_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_mapped_type[] = {  {&_swigt__p_mapped_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_output_aborter[] = {  {&_swigt__p_output_aborter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_output_pref[] = {  {&_swigt__p_output_pref, 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_f_r_q_const__std__vector__unsigned_int_std__allocator__unsigned_int_____p_void__void[] = {  {&_swigt__p_p_f_r_q_const__std__vector__unsigned_int_std__allocator__unsigned_int_____p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_power_state[] = {  {&_swigt__p_power_state, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_prop_map[] = {  {&_swigt__p_prop_map, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ref_set[] = {  {&_swigt__p_ref_set, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_repr_t[] = {  {&_swigt__p_repr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_rs_pairs[] = {  {&_swigt__p_rs_pairs, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_safe_point[] = {  {&_swigt__p_safe_point, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_safe_stash[] = {  {&_swigt__p_safe_stash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_scc_node[] = {  {&_swigt__p_scc_node, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_scc_succs[] = {  {&_swigt__p_scc_succs, 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_seq_t[] = {  {&_swigt__p_seq_t, 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_signed_char[] = {  {&_swigt__p_signed_char, 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_spot__acc_cond[] = {  {&_swigt__p_spot__acc_cond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__acc_cond__acc_code[] = {  {&_swigt__p_spot__acc_cond__acc_code, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__acc_cond__acc_word[] = {  {&_swigt__p_spot__acc_cond__acc_word, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__acc_cond__mark_t[] = {  {&_swigt__p_spot__acc_cond__mark_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__acc_cond__rs_pair[] = {  {&_swigt__p_spot__acc_cond__rs_pair, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__acd[] = {  {&_swigt__p_spot__acd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__aig[] = {  {&_swigt__p_spot__aig, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__automaton_parser_options[] = {  {&_swigt__p_spot__automaton_parser_options, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__automaton_stream_parser[] = {  {&_swigt__p_spot__automaton_stream_parser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__bdd_dict[] = {  {&_swigt__p_spot__bdd_dict, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__declarative_environment[] = {  {&_swigt__p_spot__declarative_environment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__default_environment[] = {  {&_swigt__p_spot__default_environment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__digraphT_spot__kripke_graph_state_void_t[] = {  {&_swigt__p_spot__digraphT_spot__kripke_graph_state_void_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__digraphT_spot__kripke_graph_state_void_t__edge[] = {  {&_swigt__p_spot__digraphT_spot__kripke_graph_state_void_t__edge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t[] = {  {&_swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge[] = {  {&_swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_storage_t[] = {  {&_swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_storage_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__state_storage_t[] = {  {&_swigt__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__state_storage_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__emptiness_check[] = {  {&_swigt__p_spot__emptiness_check, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__emptiness_check_instantiator[] = {  {&_swigt__p_spot__emptiness_check_instantiator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__emptiness_check_result[] = {  {&_swigt__p_spot__emptiness_check_result, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__environment[] = {  {&_swigt__p_spot__environment, 0, 0, 0},  {&_swigt__p_spot__declarative_environment, _p_spot__declarative_environmentTo_p_spot__environment, 0, 0},  {&_swigt__p_spot__default_environment, _p_spot__default_environmentTo_p_spot__environment, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__fair_kripke[] = {  {&_swigt__p_spot__fair_kripke, 0, 0, 0},  {&_swigt__p_spot__kripke, _p_spot__kripkeTo_p_spot__fair_kripke, 0, 0},  {&_swigt__p_spot__kripke_graph, _p_spot__kripke_graphTo_p_spot__fair_kripke, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__fair_kripke_succ_iterator[] = {  {&_swigt__p_spot__fair_kripke_succ_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__formula[] = {  {&_swigt__p_spot__formula, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__game_relabeling_map[] = {  {&_swigt__p_spot__game_relabeling_map, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__hoa_alias_formater[] = {  {&_swigt__p_spot__hoa_alias_formater, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t[] = {  {&_swigt__p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t[] = {  {&_swigt__p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t[] = {  {&_swigt__p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t[] = {  {&_swigt__p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t[] = {  {&_swigt__p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t, 0, 0, 0},  {&_swigt__p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, _p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_tTo_p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t[] = {  {&_swigt__p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t, 0, 0, 0},  {&_swigt__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, _p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_tTo_p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__boxed_labelT_void_true_t[] = {  {&_swigt__p_spot__internal__boxed_labelT_void_true_t, 0, 0, 0},  {&_swigt__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, _p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_tTo_p_spot__internal__boxed_labelT_void_true_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__const_universal_dests[] = {  {&_swigt__p_spot__internal__const_universal_dests, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t[] = {  {&_swigt__p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t[] = {  {&_swigt__p_spot__internal__edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t[] = {  {&_swigt__p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0, 0, 0},  {&_swigt__p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, _p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_tTo_p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t[] = {  {&_swigt__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t[] = {  {&_swigt__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__keep_all[] = {  {&_swigt__p_spot__internal__keep_all, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__keep_inner_scc[] = {  {&_swigt__p_spot__internal__keep_inner_scc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t[] = {  {&_swigt__p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__mark_container[] = {  {&_swigt__p_spot__internal__mark_container, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__mark_iterator[] = {  {&_swigt__p_spot__internal__mark_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t[] = {  {&_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__dv_t[] = {  {&_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__dv_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__state_iterator[] = {  {&_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__state_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__sv_t[] = {  {&_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__sv_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__tv_t[] = {  {&_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__tv_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t[] = {  {&_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__dv_t[] = {  {&_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__dv_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__state_iterator[] = {  {&_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__state_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__sv_t[] = {  {&_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__sv_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__tv_t[] = {  {&_swigt__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__tv_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t[] = {  {&_swigt__p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t[] = {  {&_swigt__p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t[] = {  {&_swigt__p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t[] = {  {&_swigt__p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__internal__succ_iterator[] = {  {&_swigt__p_spot__internal__succ_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__isomorphism_checker[] = {  {&_swigt__p_spot__isomorphism_checker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__kripke[] = {  {&_swigt__p_spot__kripke, 0, 0, 0},  {&_swigt__p_spot__kripke_graph, _p_spot__kripke_graphTo_p_spot__kripke, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__kripke_graph[] = {  {&_swigt__p_spot__kripke_graph, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__kripke_graph_state[] = {  {&_swigt__p_spot__kripke_graph_state, 0, 0, 0},  {&_swigt__p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t, _p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_tTo_p_spot__kripke_graph_state, 0, 0},  {&_swigt__p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, _p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_tTo_p_spot__kripke_graph_state, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__kripke_graph_succ_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t[] = {  {&_swigt__p_spot__kripke_graph_succ_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__kripke_succ_iterator[] = {  {&_swigt__p_spot__kripke_succ_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__language_containment_checker[] = {  {&_swigt__p_spot__language_containment_checker, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__location[] = {  {&_swigt__p_spot__location, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__mealy_like[] = {  {&_swigt__p_spot__mealy_like, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__minato_isop[] = {  {&_swigt__p_spot__minato_isop, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__nca_st_info[] = {  {&_swigt__p_spot__nca_st_info, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__option_map[] = {  {&_swigt__p_spot__option_map, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__outedge_combiner[] = {  {&_swigt__p_spot__outedge_combiner, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__output_aborter[] = {  {&_swigt__p_spot__output_aborter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__parallel_policy[] = {  {&_swigt__p_spot__parallel_policy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__parse_aut_error_list[] = {  {&_swigt__p_spot__parse_aut_error_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__parse_error[] = {  {&_swigt__p_spot__parse_error, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__parse_error_list[] = {  {&_swigt__p_spot__parse_error_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__parsed_aut[] = {  {&_swigt__p_spot__parsed_aut, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__parsed_formula[] = {  {&_swigt__p_spot__parsed_formula, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__postprocessor[] = {  {&_swigt__p_spot__postprocessor, 0, 0, 0},  {&_swigt__p_spot__translator, _p_spot__translatorTo_p_spot__postprocessor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__power_map[] = {  {&_swigt__p_spot__power_map, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__printable_acc_cond[] = {  {&_swigt__p_spot__printable_acc_cond, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__printable_formula[] = {  {&_swigt__p_spot__printable_formula, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__printable_long_size[] = {  {&_swigt__p_spot__printable_long_size, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__printable_scc_info[] = {  {&_swigt__p_spot__printable_scc_info, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__printable_size[] = {  {&_swigt__p_spot__printable_size, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__randltlgenerator[] = {  {&_swigt__p_spot__randltlgenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__random_boolean[] = {  {&_swigt__p_spot__random_boolean, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__random_formula[] = {  {&_swigt__p_spot__random_formula, 0, 0, 0},  {&_swigt__p_spot__random_boolean, _p_spot__random_booleanTo_p_spot__random_formula, 0, 0},  {&_swigt__p_spot__random_ltl, _p_spot__random_ltlTo_p_spot__random_formula, 0, 0},  {&_swigt__p_spot__random_psl, _p_spot__random_pslTo_p_spot__random_formula, 0, 0},  {&_swigt__p_spot__random_sere, _p_spot__random_sereTo_p_spot__random_formula, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__random_ltl[] = {  {&_swigt__p_spot__random_ltl, 0, 0, 0},  {&_swigt__p_spot__random_psl, _p_spot__random_pslTo_p_spot__random_ltl, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__random_psl[] = {  {&_swigt__p_spot__random_psl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__random_sere[] = {  {&_swigt__p_spot__random_sere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__reduce_parity_data[] = {  {&_swigt__p_spot__reduce_parity_data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__remove_ap[] = {  {&_swigt__p_spot__remove_ap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__rs_pairs_view[] = {  {&_swigt__p_spot__rs_pairs_view, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__scc_and_mark_filter[] = {  {&_swigt__p_spot__scc_and_mark_filter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__scc_info[] = {  {&_swigt__p_spot__scc_info, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__scc_info_node[] = {  {&_swigt__p_spot__scc_info_node, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__set_state[] = {  {&_swigt__p_spot__set_state, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__stat_printer[] = {  {&_swigt__p_spot__stat_printer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__state[] = {  {&_swigt__p_spot__state, 0, 0, 0},  {&_swigt__p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t, _p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_tTo_p_spot__state, 0, 0},  {&_swigt__p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t, _p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_tTo_p_spot__state, 0, 0},  {&_swigt__p_spot__kripke_graph_state, _p_spot__kripke_graph_stateTo_p_spot__state, 0, 0},  {&_swigt__p_spot__set_state, _p_spot__set_stateTo_p_spot__state, 0, 0},  {&_swigt__p_spot__state_product, _p_spot__state_productTo_p_spot__state, 0, 0},  {&_swigt__p_spot__state_ta_explicit, _p_spot__state_ta_explicitTo_p_spot__state, 0, 0},  {&_swigt__p_spot__twa_graph_state, _p_spot__twa_graph_stateTo_p_spot__state, 0, 0},  {&_swigt__p_spot__univ_remover_state, _p_spot__univ_remover_stateTo_p_spot__state, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__state_product[] = {  {&_swigt__p_spot__state_product, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__state_ptr_equal[] = {  {&_swigt__p_spot__state_ptr_equal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__state_ptr_hash[] = {  {&_swigt__p_spot__state_ptr_hash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__state_ptr_less_than[] = {  {&_swigt__p_spot__state_ptr_less_than, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__state_shared_ptr_equal[] = {  {&_swigt__p_spot__state_shared_ptr_equal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__state_shared_ptr_hash[] = {  {&_swigt__p_spot__state_shared_ptr_hash, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__state_shared_ptr_less_than[] = {  {&_swigt__p_spot__state_shared_ptr_less_than, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__state_ta_explicit[] = {  {&_swigt__p_spot__state_ta_explicit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__state_unicity_table[] = {  {&_swigt__p_spot__state_unicity_table, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__synthesis_info[] = {  {&_swigt__p_spot__synthesis_info, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__ta[] = {  {&_swigt__p_spot__ta, 0, 0, 0},  {&_swigt__p_spot__ta_explicit, _p_spot__ta_explicitTo_p_spot__ta, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__ta_explicit[] = {  {&_swigt__p_spot__ta_explicit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__ta_explicit_succ_iterator[] = {  {&_swigt__p_spot__ta_explicit_succ_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__ta_statistics[] = {  {&_swigt__p_spot__ta_statistics, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__ta_succ_iterator[] = {  {&_swigt__p_spot__ta_succ_iterator, 0, 0, 0},  {&_swigt__p_spot__ta_explicit_succ_iterator, _p_spot__ta_explicit_succ_iteratorTo_p_spot__ta_succ_iterator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__taa_succ_iterator[] = {  {&_swigt__p_spot__taa_succ_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__taa_tgba[] = {  {&_swigt__p_spot__taa_tgba, 0, 0, 0},  {&_swigt__p_spot__taa_tgba_formula, _p_spot__taa_tgba_formulaTo_p_spot__taa_tgba, 0, 0},  {&_swigt__p_spot__taa_tgba_string, _p_spot__taa_tgba_stringTo_p_spot__taa_tgba, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__taa_tgba__transition[] = {  {&_swigt__p_spot__taa_tgba__transition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__taa_tgba_formula[] = {  {&_swigt__p_spot__taa_tgba_formula, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__taa_tgba_string[] = {  {&_swigt__p_spot__taa_tgba_string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__tgta[] = {  {&_swigt__p_spot__tgta, 0, 0, 0},  {&_swigt__p_spot__tgta_explicit, _p_spot__tgta_explicitTo_p_spot__tgta, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__tgta_explicit[] = {  {&_swigt__p_spot__tgta_explicit, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__tl_simplifier[] = {  {&_swigt__p_spot__tl_simplifier, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__tl_simplifier_options[] = {  {&_swigt__p_spot__tl_simplifier_options, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__to_parity_data[] = {  {&_swigt__p_spot__to_parity_data, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__to_parity_options[] = {  {&_swigt__p_spot__to_parity_options, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__translator[] = {  {&_swigt__p_spot__translator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__trival[] = {  {&_swigt__p_spot__trival, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa[] = {  {&_swigt__p_spot__twa, 0, 0, 0},  {&_swigt__p_spot__fair_kripke, _p_spot__fair_kripkeTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__kripke, _p_spot__kripkeTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__kripke_graph, _p_spot__kripke_graphTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__taa_tgba, _p_spot__taa_tgbaTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__taa_tgba_formula, _p_spot__taa_tgba_formulaTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__taa_tgba_string, _p_spot__taa_tgba_stringTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__tgta, _p_spot__tgtaTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__tgta_explicit, _p_spot__tgta_explicitTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__twa_graph, _p_spot__twa_graphTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__twa_product, _p_spot__twa_productTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__twa_product_init, _p_spot__twa_product_initTo_p_spot__twa, 0, 0},  {&_swigt__p_spot__twa_univ_remover, _p_spot__twa_univ_removerTo_p_spot__twa, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa__prop_set[] = {  {&_swigt__p_spot__twa__prop_set, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_graph[] = {  {&_swigt__p_spot__twa_graph, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_graph_edge_data[] = {  {&_swigt__p_spot__twa_graph_edge_data, 0, 0, 0},  {&_swigt__p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t, _p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_tTo_p_spot__twa_graph_edge_data, 0, 0},  {&_swigt__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t, _p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_tTo_p_spot__twa_graph_edge_data, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_graph_state[] = {  {&_swigt__p_spot__twa_graph_state, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_product[] = {  {&_swigt__p_spot__twa_product, 0, 0, 0},  {&_swigt__p_spot__twa_product_init, _p_spot__twa_product_initTo_p_spot__twa_product, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_product_init[] = {  {&_swigt__p_spot__twa_product_init, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_run[] = {  {&_swigt__p_spot__twa_run, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_run__step[] = {  {&_swigt__p_spot__twa_run__step, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_statistics[] = {  {&_swigt__p_spot__twa_statistics, 0, 0, 0},  {&_swigt__p_spot__twa_sub_statistics, _p_spot__twa_sub_statisticsTo_p_spot__twa_statistics, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_sub_statistics[] = {  {&_swigt__p_spot__twa_sub_statistics, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_succ_iterator[] = {  {&_swigt__p_spot__twa_succ_iterator, 0, 0, 0},  {&_swigt__p_spot__fair_kripke_succ_iterator, _p_spot__fair_kripke_succ_iteratorTo_p_spot__twa_succ_iterator, 0, 0},  {&_swigt__p_spot__kripke_succ_iterator, _p_spot__kripke_succ_iteratorTo_p_spot__twa_succ_iterator, 0, 0},  {&_swigt__p_spot__ta_explicit_succ_iterator, _p_spot__ta_explicit_succ_iteratorTo_p_spot__twa_succ_iterator, 0, 0},  {&_swigt__p_spot__ta_succ_iterator, _p_spot__ta_succ_iteratorTo_p_spot__twa_succ_iterator, 0, 0},  {&_swigt__p_spot__taa_succ_iterator, _p_spot__taa_succ_iteratorTo_p_spot__twa_succ_iterator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_univ_remover[] = {  {&_swigt__p_spot__twa_univ_remover, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__twa_word[] = {  {&_swigt__p_spot__twa_word, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__unabbreviator[] = {  {&_swigt__p_spot__unabbreviator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__univ_remover_state[] = {  {&_swigt__p_spot__univ_remover_state, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_spot__zielonka_tree[] = {  {&_swigt__p_spot__zielonka_tree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_state[] = {  {&_swigt__p_state, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_state_iterator[] = {  {&_swigt__p_state_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_state_num[] = {  {&_swigt__p_state_num, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_state_set[] = {  {&_swigt__p_state_set, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_state_storage_t[] = {  {&_swigt__p_state_storage_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_state_vector[] = {  {&_swigt__p_state_vector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_states_set_t[] = {  {&_swigt__p_states_set_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_bdd_t[] = {  {&_swigt__p_std__allocatorT_bdd_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_bool_t[] = {  {&_swigt__p_std__allocatorT_bool_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_spot__acc_cond__acc_code_t[] = {  {&_swigt__p_std__allocatorT_spot__acc_cond__acc_code_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_spot__acc_cond__rs_pair_t[] = {  {&_swigt__p_std__allocatorT_spot__acc_cond__rs_pair_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_spot__acc_cond_t[] = {  {&_swigt__p_std__allocatorT_spot__acc_cond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_spot__formula_t[] = {  {&_swigt__p_std__allocatorT_spot__formula_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t[] = {  {&_swigt__p_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_spot__twa_run__step_t[] = {  {&_swigt__p_std__allocatorT_spot__twa_run__step_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_std__string_bdd_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_std__string_bdd_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t[] = {  {&_swigt__p_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t[] = {  {&_swigt__p_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_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_unsigned_int_t[] = {  {&_swigt__p_std__allocatorT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__conditionalT_std__is_constT_spot__digraphT_spot__kripke_graph_state_void_t_t__value_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_const_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_t__type[] = {  {&_swigt__p_std__conditionalT_std__is_constT_spot__digraphT_spot__kripke_graph_state_void_t_t__value_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_const_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__conditionalT_std__is_constT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t__value_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_const_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_t__type[] = {  {&_swigt__p_std__conditionalT_std__is_constT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t__value_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_const_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_std__string_fintF_t[] = {  {&_swigt__p_std__functionT_std__string_fintF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__functionT_void_fstd__ostream_R_intF_t[] = {  {&_swigt__p_std__functionT_void_fstd__ostream_R_intF_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__initializer_listT_unsigned_int_t[] = {  {&_swigt__p_std__initializer_listT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__istream[] = {  {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__lessT_spot__formula_t[] = {  {&_swigt__p_std__lessT_spot__formula_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__listT_bdd_std__allocatorT_bdd_t_t[] = {  {&_swigt__p_std__listT_bdd_std__allocatorT_bdd_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t[] = {  {&_swigt__p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__listT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__listT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t[] = {  {&_swigt__p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t[] = {  {&_swigt__p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__mapT_std__string_const_spot__formula_std__lessT_std__string_const_t_std__allocatorT_std__pairT_std__string_const_const_spot__formula_t_t_t[] = {  {&_swigt__p_std__mapT_std__string_const_spot__formula_std__lessT_std__string_const_t_std__allocatorT_std__pairT_std__string_const_const_spot__formula_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__nullptr_t[] = {  {&_swigt__p_std__nullptr_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ofstream[] = {  {&_swigt__p_std__ofstream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__optionalT_spot__synthesis_info__bench_var_t[] = {  {&_swigt__p_std__optionalT_spot__synthesis_info__bench_var_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ostream[] = {  {&_swigt__p_std__ostream, 0, 0, 0},  {&_swigt__p_std__ofstream, _p_std__ofstreamTo_p_std__ostream, 0, 0},  {&_swigt__p_std__ostringstream, _p_std__ostringstreamTo_p_std__ostream, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ostringstream[] = {  {&_swigt__p_std__ostringstream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_bool_spot__acc_cond__mark_t_t[] = {  {&_swigt__p_std__pairT_bool_spot__acc_cond__mark_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_int_spot__acc_cond__acc_code_t[] = {  {&_swigt__p_std__pairT_int_spot__acc_cond__acc_code_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_int_spot__acc_cond_t[] = {  {&_swigt__p_std__pairT_int_spot__acc_cond_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t[] = {  {&_swigt__p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t[] = {  {&_swigt__p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__string_bdd_t[] = {  {&_swigt__p_std__pairT_std__string_bdd_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t_std__vectorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_std__allocatorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_t_t_t[] = {  {&_swigt__p_std__pairT_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t_std__vectorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_std__allocatorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_unsigned_int_unsigned_int_t[] = {  {&_swigt__p_std__pairT_unsigned_int_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__runtime_error[] = {  {&_swigt__p_std__runtime_error, 0, 0, 0},  {&_swigt__p_spot__parse_error, _p_spot__parse_errorTo_p_std__runtime_error, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t[] = {  {&_swigt__p_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t[] = {  {&_swigt__p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_spot__state_const_p_spot__state_ptr_less_than_std__allocatorT_spot__state_const_p_t_t[] = {  {&_swigt__p_std__setT_spot__state_const_p_spot__state_ptr_less_than_std__allocatorT_spot__state_const_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_spot__state_p_spot__state_ptr_less_than_std__allocatorT_spot__state_p_t_t[] = {  {&_swigt__p_std__setT_spot__state_p_spot__state_ptr_less_than_std__allocatorT_spot__state_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t[] = {  {&_swigt__p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t[] = {  {&_swigt__p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__aig_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__aig_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__aig_t[] = {  {&_swigt__p_std__shared_ptrT_spot__aig_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__bdd_dict_t[] = {  {&_swigt__p_std__shared_ptrT_spot__bdd_dict_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__dstar_aut_t[] = {  {&_swigt__p_std__shared_ptrT_spot__dstar_aut_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__emptiness_check_instantiator_t[] = {  {&_swigt__p_std__shared_ptrT_spot__emptiness_check_instantiator_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__emptiness_check_result_t[] = {  {&_swigt__p_std__shared_ptrT_spot__emptiness_check_result_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__emptiness_check_t[] = {  {&_swigt__p_std__shared_ptrT_spot__emptiness_check_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__fair_kripke_t[] = {  {&_swigt__p_std__shared_ptrT_spot__fair_kripke_t, 0, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__kripke_graph_t, _p_std__shared_ptrT_spot__kripke_graph_tTo_p_std__shared_ptrT_spot__fair_kripke_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__kripke_t, _p_std__shared_ptrT_spot__kripke_tTo_p_std__shared_ptrT_spot__fair_kripke_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__kripke_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__kripke_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__kripke_graph_t[] = {  {&_swigt__p_std__shared_ptrT_spot__kripke_graph_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__kripke_t[] = {  {&_swigt__p_std__shared_ptrT_spot__kripke_t, 0, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__kripke_graph_t, _p_std__shared_ptrT_spot__kripke_graph_tTo_p_std__shared_ptrT_spot__kripke_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__parsed_aut_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__parsed_aut_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__parsed_aut_t[] = {  {&_swigt__p_std__shared_ptrT_spot__parsed_aut_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__state_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__state_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__ta_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__ta_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__ta_explicit_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__ta_explicit_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__ta_explicit_t[] = {  {&_swigt__p_std__shared_ptrT_spot__ta_explicit_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__ta_product_t[] = {  {&_swigt__p_std__shared_ptrT_spot__ta_product_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__ta_t[] = {  {&_swigt__p_std__shared_ptrT_spot__ta_t, 0, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__ta_explicit_t, _p_std__shared_ptrT_spot__ta_explicit_tTo_p_std__shared_ptrT_spot__ta_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__taa_tgba_formula_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__taa_tgba_formula_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__taa_tgba_formula_t[] = {  {&_swigt__p_std__shared_ptrT_spot__taa_tgba_formula_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__taa_tgba_string_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__taa_tgba_string_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__taa_tgba_string_t[] = {  {&_swigt__p_std__shared_ptrT_spot__taa_tgba_string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__taa_tgba_t[] = {  {&_swigt__p_std__shared_ptrT_spot__taa_tgba_t, 0, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__taa_tgba_formula_t, _p_std__shared_ptrT_spot__taa_tgba_formula_tTo_p_std__shared_ptrT_spot__taa_tgba_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__taa_tgba_string_t, _p_std__shared_ptrT_spot__taa_tgba_string_tTo_p_std__shared_ptrT_spot__taa_tgba_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__tgbasl_t[] = {  {&_swigt__p_std__shared_ptrT_spot__tgbasl_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__tgta_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__tgta_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__tgta_explicit_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__tgta_explicit_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__tgta_explicit_t[] = {  {&_swigt__p_std__shared_ptrT_spot__tgta_explicit_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__tgta_t[] = {  {&_swigt__p_std__shared_ptrT_spot__tgta_t, 0, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__tgta_explicit_t, _p_std__shared_ptrT_spot__tgta_explicit_tTo_p_std__shared_ptrT_spot__tgta_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_graph_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_graph_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_graph_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_graph_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_product_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_product_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_product_init_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_product_init_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_product_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_product_t, 0, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__twa_product_init_t, _p_std__shared_ptrT_spot__twa_product_init_tTo_p_std__shared_ptrT_spot__twa_product_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_run_const_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_run_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_run_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_run_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_t, 0, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__fair_kripke_t, _p_std__shared_ptrT_spot__fair_kripke_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__kripke_graph_t, _p_std__shared_ptrT_spot__kripke_graph_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__kripke_t, _p_std__shared_ptrT_spot__kripke_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__taa_tgba_formula_t, _p_std__shared_ptrT_spot__taa_tgba_formula_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__taa_tgba_string_t, _p_std__shared_ptrT_spot__taa_tgba_string_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__taa_tgba_t, _p_std__shared_ptrT_spot__taa_tgba_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__tgta_explicit_t, _p_std__shared_ptrT_spot__tgta_explicit_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__tgta_t, _p_std__shared_ptrT_spot__tgta_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__twa_graph_t, _p_std__shared_ptrT_spot__twa_graph_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__twa_product_init_t, _p_std__shared_ptrT_spot__twa_product_init_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__twa_product_t, _p_std__shared_ptrT_spot__twa_product_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},  {&_swigt__p_std__shared_ptrT_spot__twa_univ_remover_t, _p_std__shared_ptrT_spot__twa_univ_remover_tTo_p_std__shared_ptrT_spot__twa_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_univ_remover_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_univ_remover_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__shared_ptrT_spot__twa_word_t[] = {  {&_swigt__p_std__shared_ptrT_spot__twa_word_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__tupleT_int_spot__acc_cond__acc_code_spot__acc_cond__acc_code_t[] = {  {&_swigt__p_std__tupleT_int_spot__acc_cond__acc_code_spot__acc_cond__acc_code_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__tupleT_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t_std__vectorT_std__pairT_unsigned_int_bdd_t_std__allocatorT_std__pairT_unsigned_int_bdd_t_t_t_std__vectorT_bdd_std__allocatorT_bdd_t_t_t[] = {  {&_swigt__p_std__tupleT_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t_std__vectorT_std__pairT_unsigned_int_bdd_t_std__allocatorT_std__pairT_unsigned_int_bdd_t_t_t_std__vectorT_bdd_std__allocatorT_bdd_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__tupleT_t[] = {  {&_swigt__p_std__tupleT_t, 0, 0, 0},  {&_swigt__p_spot__internal__boxed_labelT_void_true_t, _p_spot__internal__boxed_labelT_void_true_tTo_p_std__tupleT_t, 0, 0},  {&_swigt__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t, _p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_tTo_p_std__tupleT_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unordered_setT_spot__state_const_p_spot__state_ptr_hash_spot__state_ptr_equal_t[] = {  {&_swigt__p_std__unordered_setT_spot__state_const_p_spot__state_ptr_hash_spot__state_ptr_equal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unordered_setT_std__shared_ptrT_spot__state_const_t_spot__state_shared_ptr_hash_spot__state_shared_ptr_equal_t[] = {  {&_swigt__p_std__unordered_setT_std__shared_ptrT_spot__state_const_t_spot__state_shared_ptr_hash_spot__state_shared_ptr_equal_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_bdd_std__allocatorT_bdd_t_t[] = {  {&_swigt__p_std__vectorT_bdd_std__allocatorT_bdd_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_bool_std__allocatorT_bool_t_t[] = {  {&_swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = {  {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t[] = {  {&_swigt__p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__acc_cond__mark_t_std__allocatorT_spot__acc_cond__mark_t_t_t[] = {  {&_swigt__p_std__vectorT_spot__acc_cond__mark_t_std__allocatorT_spot__acc_cond__mark_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t[] = {  {&_swigt__p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t[] = {  {&_swigt__p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__bdd_dict__bdd_info_std__allocatorT_spot__bdd_dict__bdd_info_t_t[] = {  {&_swigt__p_std__vectorT_spot__bdd_dict__bdd_info_std__allocatorT_spot__bdd_dict__bdd_info_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t[] = {  {&_swigt__p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t[] = {  {&_swigt__p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t[] = {  {&_swigt__p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__nca_st_info_p_std__allocatorT_spot__nca_st_info_p_t_t[] = {  {&_swigt__p_std__vectorT_spot__nca_st_info_p_std__allocatorT_spot__nca_st_info_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator[] = {  {&_swigt__p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_reverse_iterator[] = {  {&_swigt__p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_reverse_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_spot__zielonka_tree__zielonka_node_std__allocatorT_spot__zielonka_tree__zielonka_node_t_t[] = {  {&_swigt__p_std__vectorT_spot__zielonka_tree__zielonka_node_std__allocatorT_spot__zielonka_tree__zielonka_node_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_std__allocatorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_std__allocatorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_std__allocatorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_std__allocatorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_std__allocatorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_std__allocatorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t[] = {  {&_swigt__p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t[] = {  {&_swigt__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_steps[] = {  {&_swigt__p_steps, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_sv_t[] = {  {&_swigt__p_sv_t, 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_tv_t[] = {  {&_swigt__p_tv_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 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_long_long[] = {  {&_swigt__p_unsigned_long_long, 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_unsigned_statistics[] = {  {&_swigt__p_unsigned_statistics, 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_vf_map[] = {  {&_swigt__p_vf_map, 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 *swig_cast_initial[] = {
  _swigc__p_aliases_t,
  _swigc__p_allocator_type,
  _swigc__p_bdd,
  _swigc__p_bdd_info_map,
  _swigc__p_bitvect,
  _swigc__p_bool,
  _swigc__p_char,
  _swigc__p_const_reference,
  _swigc__p_const_states_set_t,
  _swigc__p_data_t,
  _swigc__p_difference_type,
  _swigc__p_dv_t,
  _swigc__p_ec_statistics,
  _swigc__p_edge,
  _swigc__p_edge_filter,
  _swigc__p_edge_filter_choice,
  _swigc__p_edge_storage_t,
  _swigc__p_f_r_q_const__spot__twa_graph__edge_storage_t_unsigned_int_p_void__spot__edge_filter_choice,
  _swigc__p_first_type,
  _swigc__p_fixed_size_poolT_pool_type__Safe_t,
  _swigc__p_fnode,
  _swigc__p_fv_map,
  _swigc__p_graph_t,
  _swigc__p_int,
  _swigc__p_iter_t,
  _swigc__p_iterator_category,
  _swigc__p_key_type,
  _swigc__p_long_long,
  _swigc__p_mapped_type,
  _swigc__p_output_aborter,
  _swigc__p_output_pref,
  _swigc__p_p_PyObject,
  _swigc__p_p_char,
  _swigc__p_p_f_r_q_const__std__vector__unsigned_int_std__allocator__unsigned_int_____p_void__void,
  _swigc__p_power_state,
  _swigc__p_prop_map,
  _swigc__p_ref_set,
  _swigc__p_repr_t,
  _swigc__p_rs_pairs,
  _swigc__p_safe_point,
  _swigc__p_safe_stash,
  _swigc__p_scc_node,
  _swigc__p_scc_succs,
  _swigc__p_second_type,
  _swigc__p_seq_t,
  _swigc__p_short,
  _swigc__p_signed_char,
  _swigc__p_size_type,
  _swigc__p_spot__acc_cond,
  _swigc__p_spot__acc_cond__acc_code,
  _swigc__p_spot__acc_cond__acc_word,
  _swigc__p_spot__acc_cond__mark_t,
  _swigc__p_spot__acc_cond__rs_pair,
  _swigc__p_spot__acd,
  _swigc__p_spot__aig,
  _swigc__p_spot__automaton_parser_options,
  _swigc__p_spot__automaton_stream_parser,
  _swigc__p_spot__bdd_dict,
  _swigc__p_spot__declarative_environment,
  _swigc__p_spot__default_environment,
  _swigc__p_spot__digraphT_spot__kripke_graph_state_void_t,
  _swigc__p_spot__digraphT_spot__kripke_graph_state_void_t__edge,
  _swigc__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t,
  _swigc__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge,
  _swigc__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_storage_t,
  _swigc__p_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__state_storage_t,
  _swigc__p_spot__emptiness_check,
  _swigc__p_spot__emptiness_check_instantiator,
  _swigc__p_spot__emptiness_check_result,
  _swigc__p_spot__environment,
  _swigc__p_spot__fair_kripke,
  _swigc__p_spot__fair_kripke_succ_iterator,
  _swigc__p_spot__formula,
  _swigc__p_spot__game_relabeling_map,
  _swigc__p_spot__hoa_alias_formater,
  _swigc__p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t,
  _swigc__p_spot__internal__all_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
  _swigc__p_spot__internal__all_transT_spot__digraphT_spot__kripke_graph_state_void_t_t,
  _swigc__p_spot__internal__all_transT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
  _swigc__p_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t,
  _swigc__p_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t,
  _swigc__p_spot__internal__boxed_labelT_void_true_t,
  _swigc__p_spot__internal__const_universal_dests,
  _swigc__p_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t,
  _swigc__p_spot__internal__edge_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t,
  _swigc__p_spot__internal__edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
  _swigc__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_spot__twa_graph_edge_data_false_t_t,
  _swigc__p_spot__internal__edge_storageT_unsigned_int_unsigned_int_unsigned_int_spot__internal__boxed_labelT_void_true_t_t,
  _swigc__p_spot__internal__keep_all,
  _swigc__p_spot__internal__keep_inner_scc,
  _swigc__p_spot__internal__killer_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
  _swigc__p_spot__internal__mark_container,
  _swigc__p_spot__internal__mark_iterator,
  _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t,
  _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__dv_t,
  _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__state_iterator,
  _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__sv_t,
  _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t__tv_t,
  _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t,
  _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__dv_t,
  _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__state_iterator,
  _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__sv_t,
  _swigc__p_spot__internal__scc_edge_iteratorT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t__tv_t,
  _swigc__p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_all_t,
  _swigc__p_spot__internal__scc_edgesT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_const_spot__internal__keep_inner_scc_t,
  _swigc__p_spot__internal__state_outT_spot__digraphT_spot__kripke_graph_state_void_t_t,
  _swigc__p_spot__internal__state_outT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t,
  _swigc__p_spot__internal__succ_iterator,
  _swigc__p_spot__isomorphism_checker,
  _swigc__p_spot__kripke,
  _swigc__p_spot__kripke_graph,
  _swigc__p_spot__kripke_graph_state,
  _swigc__p_spot__kripke_graph_succ_iteratorT_spot__digraphT_spot__kripke_graph_state_void_t_t,
  _swigc__p_spot__kripke_succ_iterator,
  _swigc__p_spot__language_containment_checker,
  _swigc__p_spot__location,
  _swigc__p_spot__mealy_like,
  _swigc__p_spot__minato_isop,
  _swigc__p_spot__nca_st_info,
  _swigc__p_spot__option_map,
  _swigc__p_spot__outedge_combiner,
  _swigc__p_spot__output_aborter,
  _swigc__p_spot__parallel_policy,
  _swigc__p_spot__parse_aut_error_list,
  _swigc__p_spot__parse_error,
  _swigc__p_spot__parse_error_list,
  _swigc__p_spot__parsed_aut,
  _swigc__p_spot__parsed_formula,
  _swigc__p_spot__postprocessor,
  _swigc__p_spot__power_map,
  _swigc__p_spot__printable_acc_cond,
  _swigc__p_spot__printable_formula,
  _swigc__p_spot__printable_long_size,
  _swigc__p_spot__printable_scc_info,
  _swigc__p_spot__printable_size,
  _swigc__p_spot__randltlgenerator,
  _swigc__p_spot__random_boolean,
  _swigc__p_spot__random_formula,
  _swigc__p_spot__random_ltl,
  _swigc__p_spot__random_psl,
  _swigc__p_spot__random_sere,
  _swigc__p_spot__reduce_parity_data,
  _swigc__p_spot__remove_ap,
  _swigc__p_spot__rs_pairs_view,
  _swigc__p_spot__scc_and_mark_filter,
  _swigc__p_spot__scc_info,
  _swigc__p_spot__scc_info_node,
  _swigc__p_spot__set_state,
  _swigc__p_spot__stat_printer,
  _swigc__p_spot__state,
  _swigc__p_spot__state_product,
  _swigc__p_spot__state_ptr_equal,
  _swigc__p_spot__state_ptr_hash,
  _swigc__p_spot__state_ptr_less_than,
  _swigc__p_spot__state_shared_ptr_equal,
  _swigc__p_spot__state_shared_ptr_hash,
  _swigc__p_spot__state_shared_ptr_less_than,
  _swigc__p_spot__state_ta_explicit,
  _swigc__p_spot__state_unicity_table,
  _swigc__p_spot__synthesis_info,
  _swigc__p_spot__ta,
  _swigc__p_spot__ta_explicit,
  _swigc__p_spot__ta_explicit_succ_iterator,
  _swigc__p_spot__ta_statistics,
  _swigc__p_spot__ta_succ_iterator,
  _swigc__p_spot__taa_succ_iterator,
  _swigc__p_spot__taa_tgba,
  _swigc__p_spot__taa_tgba__transition,
  _swigc__p_spot__taa_tgba_formula,
  _swigc__p_spot__taa_tgba_string,
  _swigc__p_spot__tgta,
  _swigc__p_spot__tgta_explicit,
  _swigc__p_spot__tl_simplifier,
  _swigc__p_spot__tl_simplifier_options,
  _swigc__p_spot__to_parity_data,
  _swigc__p_spot__to_parity_options,
  _swigc__p_spot__translator,
  _swigc__p_spot__trival,
  _swigc__p_spot__twa,
  _swigc__p_spot__twa__prop_set,
  _swigc__p_spot__twa_graph,
  _swigc__p_spot__twa_graph_edge_data,
  _swigc__p_spot__twa_graph_state,
  _swigc__p_spot__twa_product,
  _swigc__p_spot__twa_product_init,
  _swigc__p_spot__twa_run,
  _swigc__p_spot__twa_run__step,
  _swigc__p_spot__twa_statistics,
  _swigc__p_spot__twa_sub_statistics,
  _swigc__p_spot__twa_succ_iterator,
  _swigc__p_spot__twa_univ_remover,
  _swigc__p_spot__twa_word,
  _swigc__p_spot__unabbreviator,
  _swigc__p_spot__univ_remover_state,
  _swigc__p_spot__zielonka_tree,
  _swigc__p_state,
  _swigc__p_state_iterator,
  _swigc__p_state_num,
  _swigc__p_state_set,
  _swigc__p_state_storage_t,
  _swigc__p_state_vector,
  _swigc__p_states_set_t,
  _swigc__p_std__allocatorT_bdd_t,
  _swigc__p_std__allocatorT_bool_t,
  _swigc__p_std__allocatorT_int_t,
  _swigc__p_std__allocatorT_spot__acc_cond__acc_code_t,
  _swigc__p_std__allocatorT_spot__acc_cond__rs_pair_t,
  _swigc__p_std__allocatorT_spot__acc_cond_t,
  _swigc__p_std__allocatorT_spot__formula_t,
  _swigc__p_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t,
  _swigc__p_std__allocatorT_spot__twa_run__step_t,
  _swigc__p_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t,
  _swigc__p_std__allocatorT_std__pairT_std__string_bdd_t_t,
  _swigc__p_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t,
  _swigc__p_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t,
  _swigc__p_std__allocatorT_std__string_t,
  _swigc__p_std__allocatorT_unsigned_int_t,
  _swigc__p_std__conditionalT_std__is_constT_spot__digraphT_spot__kripke_graph_state_void_t_t__value_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_const_spot__digraphT_spot__kripke_graph_state_void_t__edge_vector_t_t__type,
  _swigc__p_std__conditionalT_std__is_constT_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t_t__value_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_const_spot__digraphT_spot__twa_graph_state_spot__twa_graph_edge_data_t__edge_vector_t_t__type,
  _swigc__p_std__functionT_std__string_fintF_t,
  _swigc__p_std__functionT_void_fstd__ostream_R_intF_t,
  _swigc__p_std__initializer_listT_unsigned_int_t,
  _swigc__p_std__invalid_argument,
  _swigc__p_std__istream,
  _swigc__p_std__lessT_spot__formula_t,
  _swigc__p_std__listT_bdd_std__allocatorT_bdd_t_t,
  _swigc__p_std__listT_spot__twa_run__step_std__allocatorT_spot__twa_run__step_t_t,
  _swigc__p_std__listT_std__string_std__allocatorT_std__string_t_t,
  _swigc__p_std__mapT_spot__formula_int_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_int_t_t_t,
  _swigc__p_std__mapT_spot__formula_spot__formula_std__lessT_spot__formula_t_std__allocatorT_std__pairT_spot__formula_const_spot__formula_t_t_t,
  _swigc__p_std__mapT_std__string_const_spot__formula_std__lessT_std__string_const_t_std__allocatorT_std__pairT_std__string_const_const_spot__formula_t_t_t,
  _swigc__p_std__nullptr_t,
  _swigc__p_std__ofstream,
  _swigc__p_std__optionalT_spot__synthesis_info__bench_var_t,
  _swigc__p_std__ostream,
  _swigc__p_std__ostringstream,
  _swigc__p_std__pairT_bool_spot__acc_cond__mark_t_t,
  _swigc__p_std__pairT_int_spot__acc_cond__acc_code_t,
  _swigc__p_std__pairT_int_spot__acc_cond_t,
  _swigc__p_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t,
  _swigc__p_std__pairT_spot__formula_std__vectorT_std__string_std__allocatorT_std__string_t_t_t,
  _swigc__p_std__pairT_std__string_bdd_t,
  _swigc__p_std__pairT_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t_std__vectorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_std__allocatorT_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t_t_t_t,
  _swigc__p_std__pairT_unsigned_int_unsigned_int_t,
  _swigc__p_std__runtime_error,
  _swigc__p_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t,
  _swigc__p_std__setT_spot__formula_std__lessT_spot__formula_t_std__allocatorT_spot__formula_t_t,
  _swigc__p_std__setT_spot__state_const_p_spot__state_ptr_less_than_std__allocatorT_spot__state_const_p_t_t,
  _swigc__p_std__setT_spot__state_p_spot__state_ptr_less_than_std__allocatorT_spot__state_p_t_t,
  _swigc__p_std__setT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_std__lessT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_std__allocatorT_std__listT_spot__taa_tgba__transition_p_std__allocatorT_spot__taa_tgba__transition_p_t_t_p_t_t,
  _swigc__p_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t,
  _swigc__p_std__shared_ptrT_spot__aig_const_t,
  _swigc__p_std__shared_ptrT_spot__aig_t,
  _swigc__p_std__shared_ptrT_spot__bdd_dict_t,
  _swigc__p_std__shared_ptrT_spot__dstar_aut_t,
  _swigc__p_std__shared_ptrT_spot__emptiness_check_instantiator_t,
  _swigc__p_std__shared_ptrT_spot__emptiness_check_result_t,
  _swigc__p_std__shared_ptrT_spot__emptiness_check_t,
  _swigc__p_std__shared_ptrT_spot__fair_kripke_t,
  _swigc__p_std__shared_ptrT_spot__kripke_const_t,
  _swigc__p_std__shared_ptrT_spot__kripke_graph_t,
  _swigc__p_std__shared_ptrT_spot__kripke_t,
  _swigc__p_std__shared_ptrT_spot__parsed_aut_const_t,
  _swigc__p_std__shared_ptrT_spot__parsed_aut_t,
  _swigc__p_std__shared_ptrT_spot__state_const_t,
  _swigc__p_std__shared_ptrT_spot__ta_const_t,
  _swigc__p_std__shared_ptrT_spot__ta_explicit_const_t,
  _swigc__p_std__shared_ptrT_spot__ta_explicit_t,
  _swigc__p_std__shared_ptrT_spot__ta_product_t,
  _swigc__p_std__shared_ptrT_spot__ta_t,
  _swigc__p_std__shared_ptrT_spot__taa_tgba_formula_const_t,
  _swigc__p_std__shared_ptrT_spot__taa_tgba_formula_t,
  _swigc__p_std__shared_ptrT_spot__taa_tgba_string_const_t,
  _swigc__p_std__shared_ptrT_spot__taa_tgba_string_t,
  _swigc__p_std__shared_ptrT_spot__taa_tgba_t,
  _swigc__p_std__shared_ptrT_spot__tgbasl_t,
  _swigc__p_std__shared_ptrT_spot__tgta_const_t,
  _swigc__p_std__shared_ptrT_spot__tgta_explicit_const_t,
  _swigc__p_std__shared_ptrT_spot__tgta_explicit_t,
  _swigc__p_std__shared_ptrT_spot__tgta_t,
  _swigc__p_std__shared_ptrT_spot__twa_const_t,
  _swigc__p_std__shared_ptrT_spot__twa_graph_const_t,
  _swigc__p_std__shared_ptrT_spot__twa_graph_t,
  _swigc__p_std__shared_ptrT_spot__twa_product_const_t,
  _swigc__p_std__shared_ptrT_spot__twa_product_init_t,
  _swigc__p_std__shared_ptrT_spot__twa_product_t,
  _swigc__p_std__shared_ptrT_spot__twa_run_const_t,
  _swigc__p_std__shared_ptrT_spot__twa_run_t,
  _swigc__p_std__shared_ptrT_spot__twa_t,
  _swigc__p_std__shared_ptrT_spot__twa_univ_remover_t,
  _swigc__p_std__shared_ptrT_spot__twa_word_t,
  _swigc__p_std__tupleT_int_spot__acc_cond__acc_code_spot__acc_cond__acc_code_t,
  _swigc__p_std__tupleT_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t_std__vectorT_std__pairT_unsigned_int_bdd_t_std__allocatorT_std__pairT_unsigned_int_bdd_t_t_t_std__vectorT_bdd_std__allocatorT_bdd_t_t_t,
  _swigc__p_std__tupleT_t,
  _swigc__p_std__unordered_setT_spot__state_const_p_spot__state_ptr_hash_spot__state_ptr_equal_t,
  _swigc__p_std__unordered_setT_std__shared_ptrT_spot__state_const_t_spot__state_shared_ptr_hash_spot__state_shared_ptr_equal_t,
  _swigc__p_std__vectorT_bdd_std__allocatorT_bdd_t_t,
  _swigc__p_std__vectorT_bool_std__allocatorT_bool_t_t,
  _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
  _swigc__p_std__vectorT_spot__acc_cond__acc_code_std__allocatorT_spot__acc_cond__acc_code_t_t,
  _swigc__p_std__vectorT_spot__acc_cond__mark_t_std__allocatorT_spot__acc_cond__mark_t_t_t,
  _swigc__p_std__vectorT_spot__acc_cond__rs_pair_std__allocatorT_spot__acc_cond__rs_pair_t_t,
  _swigc__p_std__vectorT_spot__acc_cond_std__allocatorT_spot__acc_cond_t_t,
  _swigc__p_std__vectorT_spot__bdd_dict__bdd_info_std__allocatorT_spot__bdd_dict__bdd_info_t_t,
  _swigc__p_std__vectorT_spot__formula_std__allocatorT_spot__formula_t_t,
  _swigc__p_std__vectorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_std__allocatorT_spot__internal__distate_storageT_unsigned_int_spot__internal__boxed_labelT_spot__kripke_graph_state_false_t_t_t_t,
  _swigc__p_std__vectorT_spot__mealy_like_std__allocatorT_spot__mealy_like_t_t,
  _swigc__p_std__vectorT_spot__nca_st_info_p_std__allocatorT_spot__nca_st_info_p_t_t,
  _swigc__p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_iterator,
  _swigc__p_std__vectorT_spot__scc_info_node_std__allocatorT_spot__scc_info_node_t_t__const_reverse_iterator,
  _swigc__p_std__vectorT_spot__zielonka_tree__zielonka_node_std__allocatorT_spot__zielonka_tree__zielonka_node_t_t,
  _swigc__p_std__vectorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_std__allocatorT_std__pairT_spot__acc_cond__mark_t_spot__acc_cond__mark_t_t_t_t,
  _swigc__p_std__vectorT_std__pairT_std__string_bdd_t_std__allocatorT_std__pairT_std__string_bdd_t_t_t,
  _swigc__p_std__vectorT_std__pairT_unsigned_int_unsigned_int_t_std__allocatorT_std__pairT_unsigned_int_unsigned_int_t_t_t,
  _swigc__p_std__vectorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_std__allocatorT_std__setT_spot__acc_cond__mark_t_std__lessT_spot__acc_cond__mark_t_t_std__allocatorT_spot__acc_cond__mark_t_t_t_t_t,
  _swigc__p_std__vectorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_std__allocatorT_std__setT_unsigned_int_std__lessT_unsigned_int_t_std__allocatorT_unsigned_int_t_t_t_t,
  _swigc__p_std__vectorT_std__shared_ptrT_spot__twa_graph_t_std__allocatorT_std__shared_ptrT_spot__twa_graph_t_t_t,
  _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  _swigc__p_std__vectorT_std__vectorT_int_std__allocatorT_int_t_t_std__allocatorT_std__vectorT_int_std__allocatorT_int_t_t_t_t,
  _swigc__p_std__vectorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_std__allocatorT_std__vectorT_std__string_std__allocatorT_std__string_t_t_t_t,
  _swigc__p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t,
  _swigc__p_steps,
  _swigc__p_sv_t,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_tv_t,
  _swigc__p_unsigned_char,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_long_long,
  _swigc__p_unsigned_short,
  _swigc__p_unsigned_statistics,
  _swigc__p_value_type,
  _swigc__p_vf_map,
  _swigc__p_void,
};


/* -------- 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 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 linked list. 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. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last 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 linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#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

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 *ret;
    swig_cast_info *cast;
    
#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 = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = 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;
  swig_cast_info *equiv;
  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) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->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);
        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




#ifdef __cplusplus
extern "C" {
#endif
  
  /* -----------------------------------------------------------------------------
   * Method creation and docstring support functions
   * ----------------------------------------------------------------------------- */
  
  /* -----------------------------------------------------------------------------
   * Function to find the method definition with the correct docstring for the
   * proxy module as opposed to the low-level API
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
    /* Find the function in the modified method table */
    size_t offset = 0;
    int found = 0;
    while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
      if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
        found = 1;
        break;
      }
      offset++;
    }
    /* Use the copy with the modified docstring if available */
    return found ? &SwigMethods_proxydocs[offset] : NULL;
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyInstanceMethod_New() used in Python 3
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
#if PY_VERSION_HEX >= 0x03000000
    return PyInstanceMethod_New(func);
#else
    return PyMethod_New(func, NULL, NULL);
#endif
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyStaticMethod_New()
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
    return PyStaticMethod_New(func);
  }
  
#ifdef __cplusplus
}
#endif




/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md, *globals;
  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#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();
  assert(metatype);
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_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);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule(SWIG_name, SwigMethods);
#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.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* 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);
  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);
  
  SWIG_Python_SetConstant(d, "SHARED_PTR_DISOWN",SWIG_From_int(static_cast< int >(0)));
  SWIG_Python_SetConstant(d, "trival_no_value",SWIG_From_int(static_cast< int >(spot::trival::no_value)));
  SWIG_Python_SetConstant(d, "trival_maybe_value",SWIG_From_int(static_cast< int >(spot::trival::maybe_value)));
  SWIG_Python_SetConstant(d, "trival_yes_value",SWIG_From_int(static_cast< int >(spot::trival::yes_value)));
  SWIG_Python_SetConstant(d, "op_ff",SWIG_From_int(static_cast< int >(spot::op::ff)));
  SWIG_Python_SetConstant(d, "op_tt",SWIG_From_int(static_cast< int >(spot::op::tt)));
  SWIG_Python_SetConstant(d, "op_eword",SWIG_From_int(static_cast< int >(spot::op::eword)));
  SWIG_Python_SetConstant(d, "op_ap",SWIG_From_int(static_cast< int >(spot::op::ap)));
  SWIG_Python_SetConstant(d, "op_Not",SWIG_From_int(static_cast< int >(spot::op::Not)));
  SWIG_Python_SetConstant(d, "op_X",SWIG_From_int(static_cast< int >(spot::op::X)));
  SWIG_Python_SetConstant(d, "op_F",SWIG_From_int(static_cast< int >(spot::op::F)));
  SWIG_Python_SetConstant(d, "op_G",SWIG_From_int(static_cast< int >(spot::op::G)));
  SWIG_Python_SetConstant(d, "op_Closure",SWIG_From_int(static_cast< int >(spot::op::Closure)));
  SWIG_Python_SetConstant(d, "op_NegClosure",SWIG_From_int(static_cast< int >(spot::op::NegClosure)));
  SWIG_Python_SetConstant(d, "op_NegClosureMarked",SWIG_From_int(static_cast< int >(spot::op::NegClosureMarked)));
  SWIG_Python_SetConstant(d, "op_Xor",SWIG_From_int(static_cast< int >(spot::op::Xor)));
  SWIG_Python_SetConstant(d, "op_Implies",SWIG_From_int(static_cast< int >(spot::op::Implies)));
  SWIG_Python_SetConstant(d, "op_Equiv",SWIG_From_int(static_cast< int >(spot::op::Equiv)));
  SWIG_Python_SetConstant(d, "op_U",SWIG_From_int(static_cast< int >(spot::op::U)));
  SWIG_Python_SetConstant(d, "op_R",SWIG_From_int(static_cast< int >(spot::op::R)));
  SWIG_Python_SetConstant(d, "op_W",SWIG_From_int(static_cast< int >(spot::op::W)));
  SWIG_Python_SetConstant(d, "op_M",SWIG_From_int(static_cast< int >(spot::op::M)));
  SWIG_Python_SetConstant(d, "op_EConcat",SWIG_From_int(static_cast< int >(spot::op::EConcat)));
  SWIG_Python_SetConstant(d, "op_EConcatMarked",SWIG_From_int(static_cast< int >(spot::op::EConcatMarked)));
  SWIG_Python_SetConstant(d, "op_UConcat",SWIG_From_int(static_cast< int >(spot::op::UConcat)));
  SWIG_Python_SetConstant(d, "op_Or",SWIG_From_int(static_cast< int >(spot::op::Or)));
  SWIG_Python_SetConstant(d, "op_OrRat",SWIG_From_int(static_cast< int >(spot::op::OrRat)));
  SWIG_Python_SetConstant(d, "op_And",SWIG_From_int(static_cast< int >(spot::op::And)));
  SWIG_Python_SetConstant(d, "op_AndRat",SWIG_From_int(static_cast< int >(spot::op::AndRat)));
  SWIG_Python_SetConstant(d, "op_AndNLM",SWIG_From_int(static_cast< int >(spot::op::AndNLM)));
  SWIG_Python_SetConstant(d, "op_Concat",SWIG_From_int(static_cast< int >(spot::op::Concat)));
  SWIG_Python_SetConstant(d, "op_Fusion",SWIG_From_int(static_cast< int >(spot::op::Fusion)));
  SWIG_Python_SetConstant(d, "op_Star",SWIG_From_int(static_cast< int >(spot::op::Star)));
  SWIG_Python_SetConstant(d, "op_FStar",SWIG_From_int(static_cast< int >(spot::op::FStar)));
  SWIG_Python_SetConstant(d, "op_first_match",SWIG_From_int(static_cast< int >(spot::op::first_match)));
  
  // thread safe initialization
  swig::container_owner_attribute();
  
  SWIG_Python_SetConstant(d, "bdd_dict_anon",SWIG_From_int(static_cast< int >(spot::bdd_dict::anon)));
  SWIG_Python_SetConstant(d, "bdd_dict_var",SWIG_From_int(static_cast< int >(spot::bdd_dict::var)));
  SWIG_Python_SetConstant(d, "bdd_dict_acc",SWIG_From_int(static_cast< int >(spot::bdd_dict::acc)));
  SWIG_Python_SetConstant(d, "acc_cond_acc_op_Inf",SWIG_From_int(static_cast< int >(spot::acc_cond::acc_op::Inf)));
  SWIG_Python_SetConstant(d, "acc_cond_acc_op_Fin",SWIG_From_int(static_cast< int >(spot::acc_cond::acc_op::Fin)));
  SWIG_Python_SetConstant(d, "acc_cond_acc_op_InfNeg",SWIG_From_int(static_cast< int >(spot::acc_cond::acc_op::InfNeg)));
  SWIG_Python_SetConstant(d, "acc_cond_acc_op_FinNeg",SWIG_From_int(static_cast< int >(spot::acc_cond::acc_op::FinNeg)));
  SWIG_Python_SetConstant(d, "acc_cond_acc_op_And",SWIG_From_int(static_cast< int >(spot::acc_cond::acc_op::And)));
  SWIG_Python_SetConstant(d, "acc_cond_acc_op_Or",SWIG_From_int(static_cast< int >(spot::acc_cond::acc_op::Or)));
  globals = SWIG_globals();
  if (!globals) {
    PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals.");
#if PY_VERSION_HEX >= 0x03000000
    return NULL;
#else
    return;
#endif
  }
  PyDict_SetItemString(md, "cvar", globals);
  SWIG_addvarlink(globals, "default_unabbrev_string", Swig_var_default_unabbrev_string_get, Swig_var_default_unabbrev_string_set);
  SWIG_Python_SetConstant(d, "randltlgenerator_Bool",SWIG_From_int(static_cast< int >(spot::randltlgenerator::Bool)));
  SWIG_Python_SetConstant(d, "randltlgenerator_LTL",SWIG_From_int(static_cast< int >(spot::randltlgenerator::LTL)));
  SWIG_Python_SetConstant(d, "randltlgenerator_SERE",SWIG_From_int(static_cast< int >(spot::randltlgenerator::SERE)));
  SWIG_Python_SetConstant(d, "randltlgenerator_PSL",SWIG_From_int(static_cast< int >(spot::randltlgenerator::PSL)));
  SWIG_Python_SetConstant(d, "randltlgenerator_MAX_TRIALS",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(spot::randltlgenerator::MAX_TRIALS)));
  SWIG_Python_SetConstant(d, "prcheck_Auto",SWIG_From_int(static_cast< int >(spot::prcheck::Auto)));
  SWIG_Python_SetConstant(d, "prcheck_via_CoBuchi",SWIG_From_int(static_cast< int >(spot::prcheck::via_CoBuchi)));
  SWIG_Python_SetConstant(d, "prcheck_via_Rabin",SWIG_From_int(static_cast< int >(spot::prcheck::via_Rabin)));
  SWIG_Python_SetConstant(d, "prcheck_via_Parity",SWIG_From_int(static_cast< int >(spot::prcheck::via_Parity)));
  SWIG_Python_SetConstant(d, "ocheck_Auto",SWIG_From_int(static_cast< int >(spot::ocheck::Auto)));
  SWIG_Python_SetConstant(d, "ocheck_via_CoBuchi",SWIG_From_int(static_cast< int >(spot::ocheck::via_CoBuchi)));
  SWIG_Python_SetConstant(d, "ocheck_via_Rabin",SWIG_From_int(static_cast< int >(spot::ocheck::via_Rabin)));
  SWIG_Python_SetConstant(d, "ocheck_via_WDBA",SWIG_From_int(static_cast< int >(spot::ocheck::via_WDBA)));
  SWIG_Python_SetConstant(d, "Abc",SWIG_From_int(static_cast< int >(spot::Abc)));
  SWIG_Python_SetConstant(d, "Pnn",SWIG_From_int(static_cast< int >(spot::Pnn)));
  SWIG_Python_SetConstant(d, "edge_filter_choice_keep",SWIG_From_int(static_cast< int >(spot::edge_filter_choice::keep)));
  SWIG_Python_SetConstant(d, "edge_filter_choice_ignore",SWIG_From_int(static_cast< int >(spot::edge_filter_choice::ignore)));
  SWIG_Python_SetConstant(d, "edge_filter_choice_cut",SWIG_From_int(static_cast< int >(spot::edge_filter_choice::cut)));
  SWIG_Python_SetConstant(d, "scc_info_options_NONE",SWIG_From_int(static_cast< int >(spot::scc_info_options::NONE)));
  SWIG_Python_SetConstant(d, "scc_info_options_STOP_ON_ACC",SWIG_From_int(static_cast< int >(spot::scc_info_options::STOP_ON_ACC)));
  SWIG_Python_SetConstant(d, "scc_info_options_TRACK_STATES",SWIG_From_int(static_cast< int >(spot::scc_info_options::TRACK_STATES)));
  SWIG_Python_SetConstant(d, "scc_info_options_TRACK_SUCCS",SWIG_From_int(static_cast< int >(spot::scc_info_options::TRACK_SUCCS)));
  SWIG_Python_SetConstant(d, "scc_info_options_TRACK_STATES_IF_FIN_USED",SWIG_From_int(static_cast< int >(spot::scc_info_options::TRACK_STATES_IF_FIN_USED)));
  SWIG_Python_SetConstant(d, "scc_info_options_ALL",SWIG_From_int(static_cast< int >(spot::scc_info_options::ALL)));
  SWIG_Python_SetConstant(d, "parity_kind_max",SWIG_From_int(static_cast< int >(spot::parity_kind_max)));
  SWIG_Python_SetConstant(d, "parity_kind_min",SWIG_From_int(static_cast< int >(spot::parity_kind_min)));
  SWIG_Python_SetConstant(d, "parity_kind_same",SWIG_From_int(static_cast< int >(spot::parity_kind_same)));
  SWIG_Python_SetConstant(d, "parity_kind_any",SWIG_From_int(static_cast< int >(spot::parity_kind_any)));
  SWIG_Python_SetConstant(d, "parity_style_odd",SWIG_From_int(static_cast< int >(spot::parity_style_odd)));
  SWIG_Python_SetConstant(d, "parity_style_even",SWIG_From_int(static_cast< int >(spot::parity_style_even)));
  SWIG_Python_SetConstant(d, "parity_style_same",SWIG_From_int(static_cast< int >(spot::parity_style_same)));
  SWIG_Python_SetConstant(d, "parity_style_any",SWIG_From_int(static_cast< int >(spot::parity_style_any)));
  SWIG_Python_SetConstant(d, "postprocessor_TGBA",SWIG_From_int(static_cast< int >(spot::postprocessor::TGBA)));
  SWIG_Python_SetConstant(d, "postprocessor_GeneralizedBuchi",SWIG_From_int(static_cast< int >(spot::postprocessor::GeneralizedBuchi)));
  SWIG_Python_SetConstant(d, "postprocessor_BA",SWIG_From_int(static_cast< int >(spot::postprocessor::BA)));
  SWIG_Python_SetConstant(d, "postprocessor_Monitor",SWIG_From_int(static_cast< int >(spot::postprocessor::Monitor)));
  SWIG_Python_SetConstant(d, "postprocessor_Generic",SWIG_From_int(static_cast< int >(spot::postprocessor::Generic)));
  SWIG_Python_SetConstant(d, "postprocessor_Parity",SWIG_From_int(static_cast< int >(spot::postprocessor::Parity)));
  SWIG_Python_SetConstant(d, "postprocessor_ParityMin",SWIG_From_int(static_cast< int >(spot::postprocessor::ParityMin)));
  SWIG_Python_SetConstant(d, "postprocessor_ParityMax",SWIG_From_int(static_cast< int >(spot::postprocessor::ParityMax)));
  SWIG_Python_SetConstant(d, "postprocessor_ParityOdd",SWIG_From_int(static_cast< int >(spot::postprocessor::ParityOdd)));
  SWIG_Python_SetConstant(d, "postprocessor_ParityEven",SWIG_From_int(static_cast< int >(spot::postprocessor::ParityEven)));
  SWIG_Python_SetConstant(d, "postprocessor_ParityMinOdd",SWIG_From_int(static_cast< int >(spot::postprocessor::ParityMinOdd)));
  SWIG_Python_SetConstant(d, "postprocessor_ParityMaxOdd",SWIG_From_int(static_cast< int >(spot::postprocessor::ParityMaxOdd)));
  SWIG_Python_SetConstant(d, "postprocessor_ParityMinEven",SWIG_From_int(static_cast< int >(spot::postprocessor::ParityMinEven)));
  SWIG_Python_SetConstant(d, "postprocessor_ParityMaxEven",SWIG_From_int(static_cast< int >(spot::postprocessor::ParityMaxEven)));
  SWIG_Python_SetConstant(d, "postprocessor_CoBuchi",SWIG_From_int(static_cast< int >(spot::postprocessor::CoBuchi)));
  SWIG_Python_SetConstant(d, "postprocessor_Buchi",SWIG_From_int(static_cast< int >(spot::postprocessor::Buchi)));
  SWIG_Python_SetConstant(d, "postprocessor_Any",SWIG_From_int(static_cast< int >(spot::postprocessor::Any)));
  SWIG_Python_SetConstant(d, "postprocessor_Small",SWIG_From_int(static_cast< int >(spot::postprocessor::Small)));
  SWIG_Python_SetConstant(d, "postprocessor_Deterministic",SWIG_From_int(static_cast< int >(spot::postprocessor::Deterministic)));
  SWIG_Python_SetConstant(d, "postprocessor_Complete",SWIG_From_int(static_cast< int >(spot::postprocessor::Complete)));
  SWIG_Python_SetConstant(d, "postprocessor_SBAcc",SWIG_From_int(static_cast< int >(spot::postprocessor::SBAcc)));
  SWIG_Python_SetConstant(d, "postprocessor_Unambiguous",SWIG_From_int(static_cast< int >(spot::postprocessor::Unambiguous)));
  SWIG_Python_SetConstant(d, "postprocessor_Colored",SWIG_From_int(static_cast< int >(spot::postprocessor::Colored)));
  SWIG_Python_SetConstant(d, "postprocessor_Low",SWIG_From_int(static_cast< int >(spot::postprocessor::Low)));
  SWIG_Python_SetConstant(d, "postprocessor_Medium",SWIG_From_int(static_cast< int >(spot::postprocessor::Medium)));
  SWIG_Python_SetConstant(d, "postprocessor_High",SWIG_From_int(static_cast< int >(spot::postprocessor::High)));
  SWIG_Python_SetConstant(d, "synthesis_info_algo_DET_SPLIT",SWIG_From_int(static_cast< int >(spot::synthesis_info::algo::DET_SPLIT)));
  SWIG_Python_SetConstant(d, "synthesis_info_algo_SPLIT_DET",SWIG_From_int(static_cast< int >(spot::synthesis_info::algo::SPLIT_DET)));
  SWIG_Python_SetConstant(d, "synthesis_info_algo_DPA_SPLIT",SWIG_From_int(static_cast< int >(spot::synthesis_info::algo::DPA_SPLIT)));
  SWIG_Python_SetConstant(d, "synthesis_info_algo_LAR",SWIG_From_int(static_cast< int >(spot::synthesis_info::algo::LAR)));
  SWIG_Python_SetConstant(d, "synthesis_info_algo_LAR_OLD",SWIG_From_int(static_cast< int >(spot::synthesis_info::algo::LAR_OLD)));
  SWIG_Python_SetConstant(d, "synthesis_info_algo_ACD",SWIG_From_int(static_cast< int >(spot::synthesis_info::algo::ACD)));
  SWIG_Python_SetConstant(d, "mealy_like_realizability_code_UNREALIZABLE",SWIG_From_int(static_cast< int >(spot::mealy_like::realizability_code::UNREALIZABLE)));
  SWIG_Python_SetConstant(d, "mealy_like_realizability_code_UNKNOWN",SWIG_From_int(static_cast< int >(spot::mealy_like::realizability_code::UNKNOWN)));
  SWIG_Python_SetConstant(d, "mealy_like_realizability_code_REALIZABLE_REGULAR",SWIG_From_int(static_cast< int >(spot::mealy_like::realizability_code::REALIZABLE_REGULAR)));
  SWIG_Python_SetConstant(d, "mealy_like_realizability_code_REALIZABLE_DTGBA",SWIG_From_int(static_cast< int >(spot::mealy_like::realizability_code::REALIZABLE_DTGBA)));
  SWIG_Python_SetConstant(d, "zielonka_tree_options_NONE",SWIG_From_int(static_cast< int >(spot::zielonka_tree_options::NONE)));
  SWIG_Python_SetConstant(d, "zielonka_tree_options_CHECK_RABIN",SWIG_From_int(static_cast< int >(spot::zielonka_tree_options::CHECK_RABIN)));
  SWIG_Python_SetConstant(d, "zielonka_tree_options_CHECK_STREETT",SWIG_From_int(static_cast< int >(spot::zielonka_tree_options::CHECK_STREETT)));
  SWIG_Python_SetConstant(d, "zielonka_tree_options_CHECK_PARITY",SWIG_From_int(static_cast< int >(spot::zielonka_tree_options::CHECK_PARITY)));
  SWIG_Python_SetConstant(d, "zielonka_tree_options_ABORT_WRONG_SHAPE",SWIG_From_int(static_cast< int >(spot::zielonka_tree_options::ABORT_WRONG_SHAPE)));
  SWIG_Python_SetConstant(d, "zielonka_tree_options_MERGE_SUBTREES",SWIG_From_int(static_cast< int >(spot::zielonka_tree_options::MERGE_SUBTREES)));
  SWIG_Python_SetConstant(d, "acd_options_NONE",SWIG_From_int(static_cast< int >(spot::acd_options::NONE)));
  SWIG_Python_SetConstant(d, "acd_options_CHECK_RABIN",SWIG_From_int(static_cast< int >(spot::acd_options::CHECK_RABIN)));
  SWIG_Python_SetConstant(d, "acd_options_CHECK_STREETT",SWIG_From_int(static_cast< int >(spot::acd_options::CHECK_STREETT)));
  SWIG_Python_SetConstant(d, "acd_options_CHECK_PARITY",SWIG_From_int(static_cast< int >(spot::acd_options::CHECK_PARITY)));
  SWIG_Python_SetConstant(d, "acd_options_ABORT_WRONG_SHAPE",SWIG_From_int(static_cast< int >(spot::acd_options::ABORT_WRONG_SHAPE)));
  SWIG_Python_SetConstant(d, "acd_options_ORDER_HEURISTIC",SWIG_From_int(static_cast< int >(spot::acd_options::ORDER_HEURISTIC)));
  SWIG_Python_SetConstant(d, "parsed_aut_type_HOA",SWIG_From_int(static_cast< int >(spot::parsed_aut_type::HOA)));
  SWIG_Python_SetConstant(d, "parsed_aut_type_NeverClaim",SWIG_From_int(static_cast< int >(spot::parsed_aut_type::NeverClaim)));
  SWIG_Python_SetConstant(d, "parsed_aut_type_LBTT",SWIG_From_int(static_cast< int >(spot::parsed_aut_type::LBTT)));
  SWIG_Python_SetConstant(d, "parsed_aut_type_DRA",SWIG_From_int(static_cast< int >(spot::parsed_aut_type::DRA)));
  SWIG_Python_SetConstant(d, "parsed_aut_type_DSA",SWIG_From_int(static_cast< int >(spot::parsed_aut_type::DSA)));
  SWIG_Python_SetConstant(d, "parsed_aut_type_PGAME",SWIG_From_int(static_cast< int >(spot::parsed_aut_type::PGAME)));
  SWIG_Python_SetConstant(d, "parsed_aut_type_Unknown",SWIG_From_int(static_cast< int >(spot::parsed_aut_type::Unknown)));
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

